github.com/cloudwan/edgelq-sdk@v1.15.4/devices/resources/v1/device/device.pb.fieldpath.go

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

package device

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 (
	api "github.com/cloudwan/edgelq-sdk/common/api"
	project "github.com/cloudwan/edgelq-sdk/devices/resources/v1/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1/service_account"
	logging_bucket "github.com/cloudwan/edgelq-sdk/logging/resources/v1/bucket"
	monitoring_bucket "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/bucket"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	latlng "google.golang.org/genproto/googleapis/type/latlng"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	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 (
	_ = &api.HealthCheckSpec{}
	_ = &project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &logging_bucket.Bucket{}
	_ = &monitoring_bucket.Bucket{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &meta.Meta{}
)

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

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

type Device_FieldPathSelector int32

const (
	Device_FieldPathSelectorName              Device_FieldPathSelector = 0
	Device_FieldPathSelectorMetadata          Device_FieldPathSelector = 1
	Device_FieldPathSelectorDisplayName       Device_FieldPathSelector = 2
	Device_FieldPathSelectorDescription       Device_FieldPathSelector = 3
	Device_FieldPathSelectorSpec              Device_FieldPathSelector = 4
	Device_FieldPathSelectorStatus            Device_FieldPathSelector = 5
	Device_FieldPathSelectorPublicListingSpec Device_FieldPathSelector = 6
)

func (s Device_FieldPathSelector) String() string {
	switch s {
	case Device_FieldPathSelectorName:
		return "name"
	case Device_FieldPathSelectorMetadata:
		return "metadata"
	case Device_FieldPathSelectorDisplayName:
		return "display_name"
	case Device_FieldPathSelectorDescription:
		return "description"
	case Device_FieldPathSelectorSpec:
		return "spec"
	case Device_FieldPathSelectorStatus:
		return "status"
	case Device_FieldPathSelectorPublicListingSpec:
		return "public_listing_spec"
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", s))
	}
}

func BuildDevice_FieldPath(fp gotenobject.RawFieldPath) (Device_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorName}, nil
		case "metadata":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorMetadata}, nil
		case "display_name", "displayName", "display-name":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorDisplayName}, nil
		case "description":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorDescription}, nil
		case "spec":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorSpec}, nil
		case "status":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorStatus}, nil
		case "public_listing_spec", "publicListingSpec", "public-listing-spec":
			return &Device_FieldTerminalPath{selector: Device_FieldPathSelectorPublicListingSpec}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Device_FieldSubPath{selector: Device_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "spec":
			if subpath, err := BuildDeviceSpec_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Device_FieldSubPath{selector: Device_FieldPathSelectorSpec, subPath: subpath}, nil
			}
		case "status":
			if subpath, err := BuildDeviceStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Device_FieldSubPath{selector: Device_FieldPathSelectorStatus, subPath: subpath}, nil
			}
		case "public_listing_spec", "publicListingSpec", "public-listing-spec":
			if subpath, err := BuildDevicePublicListingSpec_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Device_FieldSubPath{selector: Device_FieldPathSelectorPublicListingSpec, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device", fp)
}

func ParseDevice_FieldPath(rawField string) (Device_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDevice_FieldPath(fp)
}

func MustParseDevice_FieldPath(rawField string) Device_FieldPath {
	fp, err := ParseDevice_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type Device_FieldTerminalPath struct {
	selector Device_FieldPathSelector
}

var _ Device_FieldPath = (*Device_FieldTerminalPath)(nil)

func (fp *Device_FieldTerminalPath) Selector() Device_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device
func (fp *Device_FieldTerminalPath) Get(source *Device) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case Device_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case Device_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case Device_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case Device_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case Device_FieldPathSelectorSpec:
			if source.Spec != nil {
				values = append(values, source.Spec)
			}
		case Device_FieldPathSelectorStatus:
			if source.Status != nil {
				values = append(values, source.Status)
			}
		case Device_FieldPathSelectorPublicListingSpec:
			if source.PublicListingSpec != nil {
				values = append(values, source.PublicListingSpec)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device
func (fp *Device_FieldTerminalPath) GetSingle(source *Device) (interface{}, bool) {
	switch fp.selector {
	case Device_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case Device_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case Device_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case Device_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case Device_FieldPathSelectorSpec:
		res := source.GetSpec()
		return res, res != nil
	case Device_FieldPathSelectorStatus:
		res := source.GetStatus()
		return res, res != nil
	case Device_FieldPathSelectorPublicListingSpec:
		res := source.GetPublicListingSpec()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *Device_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case Device_FieldPathSelectorName:
		return (*Name)(nil)
	case Device_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case Device_FieldPathSelectorDisplayName:
		return ""
	case Device_FieldPathSelectorDescription:
		return ""
	case Device_FieldPathSelectorSpec:
		return (*Device_Spec)(nil)
	case Device_FieldPathSelectorStatus:
		return (*Device_Status)(nil)
	case Device_FieldPathSelectorPublicListingSpec:
		return (*Device_PublicListingSpec)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fp.selector))
	}
}

func (fp *Device_FieldTerminalPath) ClearValue(item *Device) {
	if item != nil {
		switch fp.selector {
		case Device_FieldPathSelectorName:
			item.Name = nil
		case Device_FieldPathSelectorMetadata:
			item.Metadata = nil
		case Device_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case Device_FieldPathSelectorDescription:
			item.Description = ""
		case Device_FieldPathSelectorSpec:
			item.Spec = nil
		case Device_FieldPathSelectorStatus:
			item.Status = nil
		case Device_FieldPathSelectorPublicListingSpec:
			item.PublicListingSpec = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device: %d", fp.selector))
		}
	}
}

func (fp *Device_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device))
}

// IsLeaf - whether field path is holds simple value
func (fp *Device_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == Device_FieldPathSelectorName ||
		fp.selector == Device_FieldPathSelectorDisplayName ||
		fp.selector == Device_FieldPathSelectorDescription
}

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

func (fp *Device_FieldTerminalPath) WithIValue(value interface{}) Device_FieldPathValue {
	switch fp.selector {
	case Device_FieldPathSelectorName:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(*Name)}
	case Device_FieldPathSelectorMetadata:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case Device_FieldPathSelectorDisplayName:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(string)}
	case Device_FieldPathSelectorDescription:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(string)}
	case Device_FieldPathSelectorSpec:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(*Device_Spec)}
	case Device_FieldPathSelectorStatus:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(*Device_Status)}
	case Device_FieldPathSelectorPublicListingSpec:
		return &Device_FieldTerminalPathValue{Device_FieldTerminalPath: *fp, value: value.(*Device_PublicListingSpec)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fp.selector))
	}
}

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

func (fp *Device_FieldTerminalPath) WithIArrayOfValues(values interface{}) Device_FieldPathArrayOfValues {
	fpaov := &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp}
	switch fp.selector {
	case Device_FieldPathSelectorName:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]*Name)}
	case Device_FieldPathSelectorMetadata:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case Device_FieldPathSelectorDisplayName:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]string)}
	case Device_FieldPathSelectorDescription:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]string)}
	case Device_FieldPathSelectorSpec:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]*Device_Spec)}
	case Device_FieldPathSelectorStatus:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]*Device_Status)}
	case Device_FieldPathSelectorPublicListingSpec:
		return &Device_FieldTerminalPathArrayOfValues{Device_FieldTerminalPath: *fp, values: values.([]*Device_PublicListingSpec)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type Device_FieldSubPath struct {
	selector Device_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ Device_FieldPath = (*Device_FieldSubPath)(nil)

func (fps *Device_FieldSubPath) Selector() Device_FieldPathSelector {
	return fps.selector
}
func (fps *Device_FieldSubPath) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *Device_FieldSubPath) AsSpecSubPath() (DeviceSpec_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpec_FieldPath)
	return res, ok
}
func (fps *Device_FieldSubPath) AsStatusSubPath() (DeviceStatus_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatus_FieldPath)
	return res, ok
}
func (fps *Device_FieldSubPath) AsPublicListingSpecSubPath() (DevicePublicListingSpec_FieldPath, bool) {
	res, ok := fps.subPath.(DevicePublicListingSpec_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Device
func (fps *Device_FieldSubPath) Get(source *Device) (values []interface{}) {
	switch fps.selector {
	case Device_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case Device_FieldPathSelectorSpec:
		values = append(values, fps.subPath.GetRaw(source.GetSpec())...)
	case Device_FieldPathSelectorStatus:
		values = append(values, fps.subPath.GetRaw(source.GetStatus())...)
	case Device_FieldPathSelectorPublicListingSpec:
		values = append(values, fps.subPath.GetRaw(source.GetPublicListingSpec())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Device
func (fps *Device_FieldSubPath) GetSingle(source *Device) (interface{}, bool) {
	switch fps.selector {
	case Device_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case Device_FieldPathSelectorSpec:
		if source.GetSpec() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSpec())
	case Device_FieldPathSelectorStatus:
		if source.GetStatus() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetStatus())
	case Device_FieldPathSelectorPublicListingSpec:
		if source.GetPublicListingSpec() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetPublicListingSpec())
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fps.selector))
	}
}

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

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

func (fps *Device_FieldSubPath) ClearValue(item *Device) {
	if item != nil {
		switch fps.selector {
		case Device_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case Device_FieldPathSelectorSpec:
			fps.subPath.ClearValueRaw(item.Spec)
		case Device_FieldPathSelectorStatus:
			fps.subPath.ClearValueRaw(item.Status)
		case Device_FieldPathSelectorPublicListingSpec:
			fps.subPath.ClearValueRaw(item.PublicListingSpec)
		default:
			panic(fmt.Sprintf("Invalid selector for Device: %d", fps.selector))
		}
	}
}

func (fps *Device_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device))
}

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

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

func (fps *Device_FieldSubPath) WithIValue(value interface{}) Device_FieldPathValue {
	return &Device_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *Device_FieldSubPath) WithIArrayOfValues(values interface{}) Device_FieldPathArrayOfValues {
	return &Device_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *Device_FieldSubPath) WithIArrayItemValue(value interface{}) Device_FieldPathArrayItemValue {
	return &Device_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseDevice_FieldPathValue(pathStr, valueStr string) Device_FieldPathValue {
	fpv, err := ParseDevice_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type Device_FieldTerminalPathValue struct {
	Device_FieldTerminalPath
	value interface{}
}

var _ Device_FieldPathValue = (*Device_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Device' as interface{}
func (fpv *Device_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *Device_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *Device_FieldTerminalPathValue) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *Device_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *Device_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *Device_FieldTerminalPathValue) AsSpecValue() (*Device_Spec, bool) {
	res, ok := fpv.value.(*Device_Spec)
	return res, ok
}
func (fpv *Device_FieldTerminalPathValue) AsStatusValue() (*Device_Status, bool) {
	res, ok := fpv.value.(*Device_Status)
	return res, ok
}
func (fpv *Device_FieldTerminalPathValue) AsPublicListingSpecValue() (*Device_PublicListingSpec, bool) {
	res, ok := fpv.value.(*Device_PublicListingSpec)
	return res, ok
}

// SetTo stores value for selected field for object Device
func (fpv *Device_FieldTerminalPathValue) SetTo(target **Device) {
	if *target == nil {
		*target = new(Device)
	}
	switch fpv.selector {
	case Device_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case Device_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case Device_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case Device_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case Device_FieldPathSelectorSpec:
		(*target).Spec = fpv.value.(*Device_Spec)
	case Device_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(*Device_Status)
	case Device_FieldPathSelectorPublicListingSpec:
		(*target).PublicListingSpec = fpv.value.(*Device_PublicListingSpec)
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'Device_FieldTerminalPathValue' with the value under path in 'Device'.
func (fpv *Device_FieldTerminalPathValue) CompareWith(source *Device) (int, bool) {
	switch fpv.selector {
	case Device_FieldPathSelectorName:
		leftValue := fpv.value.(*Name)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case Device_FieldPathSelectorMetadata:
		return 0, false
	case Device_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 Device_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 Device_FieldPathSelectorSpec:
		return 0, false
	case Device_FieldPathSelectorStatus:
		return 0, false
	case Device_FieldPathSelectorPublicListingSpec:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fpv.selector))
	}
}

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

type Device_FieldSubPathValue struct {
	Device_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ Device_FieldPathValue = (*Device_FieldSubPathValue)(nil)

func (fpvs *Device_FieldSubPathValue) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *Device_FieldSubPathValue) AsSpecPathValue() (DeviceSpec_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpec_FieldPathValue)
	return res, ok
}
func (fpvs *Device_FieldSubPathValue) AsStatusPathValue() (DeviceStatus_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatus_FieldPathValue)
	return res, ok
}
func (fpvs *Device_FieldSubPathValue) AsPublicListingSpecPathValue() (DevicePublicListingSpec_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DevicePublicListingSpec_FieldPathValue)
	return res, ok
}

func (fpvs *Device_FieldSubPathValue) SetTo(target **Device) {
	if *target == nil {
		*target = new(Device)
	}
	switch fpvs.Selector() {
	case Device_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case Device_FieldPathSelectorSpec:
		fpvs.subPathValue.(DeviceSpec_FieldPathValue).SetTo(&(*target).Spec)
	case Device_FieldPathSelectorStatus:
		fpvs.subPathValue.(DeviceStatus_FieldPathValue).SetTo(&(*target).Status)
	case Device_FieldPathSelectorPublicListingSpec:
		fpvs.subPathValue.(DevicePublicListingSpec_FieldPathValue).SetTo(&(*target).PublicListingSpec)
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *Device_FieldSubPathValue) CompareWith(source *Device) (int, bool) {
	switch fpvs.Selector() {
	case Device_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case Device_FieldPathSelectorSpec:
		return fpvs.subPathValue.(DeviceSpec_FieldPathValue).CompareWith(source.GetSpec())
	case Device_FieldPathSelectorStatus:
		return fpvs.subPathValue.(DeviceStatus_FieldPathValue).CompareWith(source.GetStatus())
	case Device_FieldPathSelectorPublicListingSpec:
		return fpvs.subPathValue.(DevicePublicListingSpec_FieldPathValue).CompareWith(source.GetPublicListingSpec())
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDevice_FieldPathArrayItemValue(pathStr, valueStr string) Device_FieldPathArrayItemValue {
	fpaiv, err := ParseDevice_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type Device_FieldTerminalPathArrayItemValue struct {
	Device_FieldTerminalPath
	value interface{}
}

var _ Device_FieldPathArrayItemValue = (*Device_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *Device_FieldTerminalPathArrayItemValue) GetSingle(source *Device) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *Device_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *Device_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Device_FieldSubPathArrayItemValue) AsSpecPathItemValue() (DeviceSpec_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpec_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Device_FieldSubPathArrayItemValue) AsStatusPathItemValue() (DeviceStatus_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatus_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Device_FieldSubPathArrayItemValue) AsPublicListingSpecPathItemValue() (DevicePublicListingSpec_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DevicePublicListingSpec_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Device'
func (fpaivs *Device_FieldSubPathArrayItemValue) ContainsValue(source *Device) bool {
	switch fpaivs.Selector() {
	case Device_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case Device_FieldPathSelectorSpec:
		return fpaivs.subPathItemValue.(DeviceSpec_FieldPathArrayItemValue).ContainsValue(source.GetSpec())
	case Device_FieldPathSelectorStatus:
		return fpaivs.subPathItemValue.(DeviceStatus_FieldPathArrayItemValue).ContainsValue(source.GetStatus())
	case Device_FieldPathSelectorPublicListingSpec:
		return fpaivs.subPathItemValue.(DevicePublicListingSpec_FieldPathArrayItemValue).ContainsValue(source.GetPublicListingSpec())
	default:
		panic(fmt.Sprintf("Invalid selector for Device: %d", fpaivs.Selector()))
	}
}

// Device_FieldPathArrayOfValues allows storing slice of values for Device fields according to their type
type Device_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	Device_FieldPath
}

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

func MustParseDevice_FieldPathArrayOfValues(pathStr, valuesStr string) Device_FieldPathArrayOfValues {
	fpaov, err := ParseDevice_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type Device_FieldTerminalPathArrayOfValues struct {
	Device_FieldTerminalPath
	values interface{}
}

var _ Device_FieldPathArrayOfValues = (*Device_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *Device_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case Device_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case Device_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case Device_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case Device_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case Device_FieldPathSelectorSpec:
		for _, v := range fpaov.values.([]*Device_Spec) {
			values = append(values, v)
		}
	case Device_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]*Device_Status) {
			values = append(values, v)
		}
	case Device_FieldPathSelectorPublicListingSpec:
		for _, v := range fpaov.values.([]*Device_PublicListingSpec) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsSpecArrayOfValues() ([]*Device_Spec, bool) {
	res, ok := fpaov.values.([]*Device_Spec)
	return res, ok
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*Device_Status, bool) {
	res, ok := fpaov.values.([]*Device_Status)
	return res, ok
}
func (fpaov *Device_FieldTerminalPathArrayOfValues) AsPublicListingSpecArrayOfValues() ([]*Device_PublicListingSpec, bool) {
	res, ok := fpaov.values.([]*Device_PublicListingSpec)
	return res, ok
}

type Device_FieldSubPathArrayOfValues struct {
	Device_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ Device_FieldPathArrayOfValues = (*Device_FieldSubPathArrayOfValues)(nil)

func (fpsaov *Device_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *Device_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Device_FieldSubPathArrayOfValues) AsSpecPathArrayOfValues() (DeviceSpec_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpec_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Device_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (DeviceStatus_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatus_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Device_FieldSubPathArrayOfValues) AsPublicListingSpecPathArrayOfValues() (DevicePublicListingSpec_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DevicePublicListingSpec_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceSpec_FieldPathSelector int32

const (
	DeviceSpec_FieldPathSelectorServiceAccount               DeviceSpec_FieldPathSelector = 0
	DeviceSpec_FieldPathSelectorLogBucket                    DeviceSpec_FieldPathSelector = 1
	DeviceSpec_FieldPathSelectorMetricsBucket                DeviceSpec_FieldPathSelector = 2
	DeviceSpec_FieldPathSelectorOsVersion                    DeviceSpec_FieldPathSelector = 3
	DeviceSpec_FieldPathSelectorNetplanYamlConfig            DeviceSpec_FieldPathSelector = 4
	DeviceSpec_FieldPathSelectorNetplanApiConfigMode         DeviceSpec_FieldPathSelector = 5
	DeviceSpec_FieldPathSelectorOsImageUrl                   DeviceSpec_FieldPathSelector = 6
	DeviceSpec_FieldPathSelectorSshConfig                    DeviceSpec_FieldPathSelector = 7
	DeviceSpec_FieldPathSelectorAttestationConfig            DeviceSpec_FieldPathSelector = 8
	DeviceSpec_FieldPathSelectorDisableDeviceDiscovery       DeviceSpec_FieldPathSelector = 9
	DeviceSpec_FieldPathSelectorLoggingConfig                DeviceSpec_FieldPathSelector = 10
	DeviceSpec_FieldPathSelectorProxyConfig                  DeviceSpec_FieldPathSelector = 11
	DeviceSpec_FieldPathSelectorLocation                     DeviceSpec_FieldPathSelector = 12
	DeviceSpec_FieldPathSelectorUsbGuard                     DeviceSpec_FieldPathSelector = 13
	DeviceSpec_FieldPathSelectorHealthChecks                 DeviceSpec_FieldPathSelector = 14
	DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback DeviceSpec_FieldPathSelector = 15
)

func (s DeviceSpec_FieldPathSelector) String() string {
	switch s {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		return "service_account"
	case DeviceSpec_FieldPathSelectorLogBucket:
		return "log_bucket"
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		return "metrics_bucket"
	case DeviceSpec_FieldPathSelectorOsVersion:
		return "os_version"
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		return "netplan_yaml_config"
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		return "netplan_api_config_mode"
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		return "os_image_url"
	case DeviceSpec_FieldPathSelectorSshConfig:
		return "ssh_config"
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return "attestation_config"
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		return "disable_device_discovery"
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return "logging_config"
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return "proxy_config"
	case DeviceSpec_FieldPathSelectorLocation:
		return "location"
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return "usb_guard"
	case DeviceSpec_FieldPathSelectorHealthChecks:
		return "health_checks"
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		return "disable_network_config_fallback"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", s))
	}
}

func BuildDeviceSpec_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_account", "serviceAccount", "service-account":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorServiceAccount}, nil
		case "log_bucket", "logBucket", "log-bucket":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorLogBucket}, nil
		case "metrics_bucket", "metricsBucket", "metrics-bucket":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorMetricsBucket}, nil
		case "os_version", "osVersion", "os-version":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorOsVersion}, nil
		case "netplan_yaml_config", "netplanYamlConfig", "netplan-yaml-config":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorNetplanYamlConfig}, nil
		case "netplan_api_config_mode", "netplanApiConfigMode", "netplan-api-config-mode":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorNetplanApiConfigMode}, nil
		case "os_image_url", "osImageUrl", "os-image-url":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorOsImageUrl}, nil
		case "ssh_config", "sshConfig", "ssh-config":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorSshConfig}, nil
		case "attestation_config", "attestationConfig", "attestation-config":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorAttestationConfig}, nil
		case "disable_device_discovery", "disableDeviceDiscovery", "disable-device-discovery":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorDisableDeviceDiscovery}, nil
		case "logging_config", "loggingConfig", "logging-config":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorLoggingConfig}, nil
		case "proxy_config", "proxyConfig", "proxy-config":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorProxyConfig}, nil
		case "location":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorLocation}, nil
		case "usb_guard", "usbGuard", "usb-guard":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorUsbGuard}, nil
		case "health_checks", "healthChecks", "health-checks":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorHealthChecks}, nil
		case "disable_network_config_fallback", "disableNetworkConfigFallback", "disable-network-config-fallback":
			return &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback}, nil
		}
	} else {
		switch fp[0] {
		case "ssh_config", "sshConfig", "ssh-config":
			if subpath, err := BuildDeviceSpecSSHConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorSshConfig, subPath: subpath}, nil
			}
		case "attestation_config", "attestationConfig", "attestation-config":
			if subpath, err := BuildDeviceSpecAttestationConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorAttestationConfig, subPath: subpath}, nil
			}
		case "logging_config", "loggingConfig", "logging-config":
			if subpath, err := BuildDeviceSpecLoggingConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorLoggingConfig, subPath: subpath}, nil
			}
		case "proxy_config", "proxyConfig", "proxy-config":
			if subpath, err := BuildDeviceSpecProxyConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorProxyConfig, subPath: subpath}, nil
			}
		case "location":
			if subpath, err := BuildDeviceSpecLocation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorLocation, subPath: subpath}, nil
			}
		case "usb_guard", "usbGuard", "usb-guard":
			if subpath, err := BuildDeviceSpecUSBGuard_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorUsbGuard, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec", fp)
}

func ParseDeviceSpec_FieldPath(rawField string) (DeviceSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpec_FieldPath(fp)
}

func MustParseDeviceSpec_FieldPath(rawField string) DeviceSpec_FieldPath {
	fp, err := ParseDeviceSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpec_FieldTerminalPath struct {
	selector DeviceSpec_FieldPathSelector
}

var _ DeviceSpec_FieldPath = (*DeviceSpec_FieldTerminalPath)(nil)

func (fp *DeviceSpec_FieldTerminalPath) Selector() DeviceSpec_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Spec
func (fp *DeviceSpec_FieldTerminalPath) Get(source *Device_Spec) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceSpec_FieldPathSelectorServiceAccount:
			if source.ServiceAccount != nil {
				values = append(values, source.ServiceAccount)
			}
		case DeviceSpec_FieldPathSelectorLogBucket:
			if source.LogBucket != nil {
				values = append(values, source.LogBucket)
			}
		case DeviceSpec_FieldPathSelectorMetricsBucket:
			if source.MetricsBucket != nil {
				values = append(values, source.MetricsBucket)
			}
		case DeviceSpec_FieldPathSelectorOsVersion:
			values = append(values, source.OsVersion)
		case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
			values = append(values, source.NetplanYamlConfig)
		case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
			values = append(values, source.NetplanApiConfigMode)
		case DeviceSpec_FieldPathSelectorOsImageUrl:
			values = append(values, source.OsImageUrl)
		case DeviceSpec_FieldPathSelectorSshConfig:
			if source.SshConfig != nil {
				values = append(values, source.SshConfig)
			}
		case DeviceSpec_FieldPathSelectorAttestationConfig:
			if source.AttestationConfig != nil {
				values = append(values, source.AttestationConfig)
			}
		case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
			values = append(values, source.DisableDeviceDiscovery)
		case DeviceSpec_FieldPathSelectorLoggingConfig:
			if source.LoggingConfig != nil {
				values = append(values, source.LoggingConfig)
			}
		case DeviceSpec_FieldPathSelectorProxyConfig:
			if source.ProxyConfig != nil {
				values = append(values, source.ProxyConfig)
			}
		case DeviceSpec_FieldPathSelectorLocation:
			if source.Location != nil {
				values = append(values, source.Location)
			}
		case DeviceSpec_FieldPathSelectorUsbGuard:
			if source.UsbGuard != nil {
				values = append(values, source.UsbGuard)
			}
		case DeviceSpec_FieldPathSelectorHealthChecks:
			for _, value := range source.GetHealthChecks() {
				values = append(values, value)
			}
		case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
			values = append(values, source.DisableNetworkConfigFallback)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Spec
func (fp *DeviceSpec_FieldTerminalPath) GetSingle(source *Device_Spec) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		res := source.GetServiceAccount()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorLogBucket:
		res := source.GetLogBucket()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		res := source.GetMetricsBucket()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorOsVersion:
		return source.GetOsVersion(), source != nil
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		return source.GetNetplanYamlConfig(), source != nil
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		return source.GetNetplanApiConfigMode(), source != nil
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		return source.GetOsImageUrl(), source != nil
	case DeviceSpec_FieldPathSelectorSshConfig:
		res := source.GetSshConfig()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		res := source.GetAttestationConfig()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		return source.GetDisableDeviceDiscovery(), source != nil
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		res := source.GetLoggingConfig()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorProxyConfig:
		res := source.GetProxyConfig()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorLocation:
		res := source.GetLocation()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorUsbGuard:
		res := source.GetUsbGuard()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorHealthChecks:
		res := source.GetHealthChecks()
		return res, res != nil
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		return source.GetDisableNetworkConfigFallback(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		return (*iam_service_account.Reference)(nil)
	case DeviceSpec_FieldPathSelectorLogBucket:
		return (*logging_bucket.Reference)(nil)
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		return (*monitoring_bucket.Reference)(nil)
	case DeviceSpec_FieldPathSelectorOsVersion:
		return ""
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		return ""
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		return Device_Spec_MERGE
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		return ""
	case DeviceSpec_FieldPathSelectorSshConfig:
		return (*Device_Spec_SSHConfig)(nil)
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return (*Device_Spec_AttestationConfig)(nil)
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		return false
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return (*Device_Spec_LoggingConfig)(nil)
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return (*Device_Spec_ProxyConfig)(nil)
	case DeviceSpec_FieldPathSelectorLocation:
		return (*Device_Spec_Location)(nil)
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return (*Device_Spec_USBGuard)(nil)
	case DeviceSpec_FieldPathSelectorHealthChecks:
		return ([]*api.HealthCheckSpec)(nil)
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
	}
}

func (fp *DeviceSpec_FieldTerminalPath) ClearValue(item *Device_Spec) {
	if item != nil {
		switch fp.selector {
		case DeviceSpec_FieldPathSelectorServiceAccount:
			item.ServiceAccount = nil
		case DeviceSpec_FieldPathSelectorLogBucket:
			item.LogBucket = nil
		case DeviceSpec_FieldPathSelectorMetricsBucket:
			item.MetricsBucket = nil
		case DeviceSpec_FieldPathSelectorOsVersion:
			item.OsVersion = ""
		case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
			item.NetplanYamlConfig = ""
		case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
			item.NetplanApiConfigMode = Device_Spec_MERGE
		case DeviceSpec_FieldPathSelectorOsImageUrl:
			item.OsImageUrl = ""
		case DeviceSpec_FieldPathSelectorSshConfig:
			item.SshConfig = nil
		case DeviceSpec_FieldPathSelectorAttestationConfig:
			item.AttestationConfig = nil
		case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
			item.DisableDeviceDiscovery = false
		case DeviceSpec_FieldPathSelectorLoggingConfig:
			item.LoggingConfig = nil
		case DeviceSpec_FieldPathSelectorProxyConfig:
			item.ProxyConfig = nil
		case DeviceSpec_FieldPathSelectorLocation:
			item.Location = nil
		case DeviceSpec_FieldPathSelectorUsbGuard:
			item.UsbGuard = nil
		case DeviceSpec_FieldPathSelectorHealthChecks:
			item.HealthChecks = nil
		case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
			item.DisableNetworkConfigFallback = false
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpec_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpec_FieldPathSelectorServiceAccount ||
		fp.selector == DeviceSpec_FieldPathSelectorLogBucket ||
		fp.selector == DeviceSpec_FieldPathSelectorMetricsBucket ||
		fp.selector == DeviceSpec_FieldPathSelectorOsVersion ||
		fp.selector == DeviceSpec_FieldPathSelectorNetplanYamlConfig ||
		fp.selector == DeviceSpec_FieldPathSelectorNetplanApiConfigMode ||
		fp.selector == DeviceSpec_FieldPathSelectorOsImageUrl ||
		fp.selector == DeviceSpec_FieldPathSelectorDisableDeviceDiscovery ||
		fp.selector == DeviceSpec_FieldPathSelectorHealthChecks ||
		fp.selector == DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback
}

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

func (fp *DeviceSpec_FieldTerminalPath) WithIValue(value interface{}) DeviceSpec_FieldPathValue {
	switch fp.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*iam_service_account.Reference)}
	case DeviceSpec_FieldPathSelectorLogBucket:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*logging_bucket.Reference)}
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*monitoring_bucket.Reference)}
	case DeviceSpec_FieldPathSelectorOsVersion:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(Device_Spec_NetworkConfigMode)}
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpec_FieldPathSelectorSshConfig:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*Device_Spec_SSHConfig)}
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*Device_Spec_AttestationConfig)}
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*Device_Spec_LoggingConfig)}
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*Device_Spec_ProxyConfig)}
	case DeviceSpec_FieldPathSelectorLocation:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*Device_Spec_Location)}
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*Device_Spec_USBGuard)}
	case DeviceSpec_FieldPathSelectorHealthChecks:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.([]*api.HealthCheckSpec)}
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		return &DeviceSpec_FieldTerminalPathValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
	}
}

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

func (fp *DeviceSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpec_FieldPathArrayOfValues {
	fpaov := &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*iam_service_account.Reference)}
	case DeviceSpec_FieldPathSelectorLogBucket:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*logging_bucket.Reference)}
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*monitoring_bucket.Reference)}
	case DeviceSpec_FieldPathSelectorOsVersion:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]Device_Spec_NetworkConfigMode)}
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpec_FieldPathSelectorSshConfig:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*Device_Spec_SSHConfig)}
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*Device_Spec_AttestationConfig)}
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*Device_Spec_LoggingConfig)}
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*Device_Spec_ProxyConfig)}
	case DeviceSpec_FieldPathSelectorLocation:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*Device_Spec_Location)}
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]*Device_Spec_USBGuard)}
	case DeviceSpec_FieldPathSelectorHealthChecks:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([][]*api.HealthCheckSpec)}
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		return &DeviceSpec_FieldTerminalPathArrayOfValues{DeviceSpec_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpec_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpec_FieldPathSelectorHealthChecks:
		return &DeviceSpec_FieldTerminalPathArrayItemValue{DeviceSpec_FieldTerminalPath: *fp, value: value.(*api.HealthCheckSpec)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fp.selector))
	}
}

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

type DeviceSpec_FieldSubPath struct {
	selector DeviceSpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceSpec_FieldPath = (*DeviceSpec_FieldSubPath)(nil)

func (fps *DeviceSpec_FieldSubPath) Selector() DeviceSpec_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceSpec_FieldSubPath) AsSshConfigSubPath() (DeviceSpecSSHConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecSSHConfig_FieldPath)
	return res, ok
}
func (fps *DeviceSpec_FieldSubPath) AsAttestationConfigSubPath() (DeviceSpecAttestationConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecAttestationConfig_FieldPath)
	return res, ok
}
func (fps *DeviceSpec_FieldSubPath) AsLoggingConfigSubPath() (DeviceSpecLoggingConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecLoggingConfig_FieldPath)
	return res, ok
}
func (fps *DeviceSpec_FieldSubPath) AsProxyConfigSubPath() (DeviceSpecProxyConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecProxyConfig_FieldPath)
	return res, ok
}
func (fps *DeviceSpec_FieldSubPath) AsLocationSubPath() (DeviceSpecLocation_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecLocation_FieldPath)
	return res, ok
}
func (fps *DeviceSpec_FieldSubPath) AsUsbGuardSubPath() (DeviceSpecUSBGuard_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecUSBGuard_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Device_Spec
func (fps *DeviceSpec_FieldSubPath) Get(source *Device_Spec) (values []interface{}) {
	switch fps.selector {
	case DeviceSpec_FieldPathSelectorSshConfig:
		values = append(values, fps.subPath.GetRaw(source.GetSshConfig())...)
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		values = append(values, fps.subPath.GetRaw(source.GetAttestationConfig())...)
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		values = append(values, fps.subPath.GetRaw(source.GetLoggingConfig())...)
	case DeviceSpec_FieldPathSelectorProxyConfig:
		values = append(values, fps.subPath.GetRaw(source.GetProxyConfig())...)
	case DeviceSpec_FieldPathSelectorLocation:
		values = append(values, fps.subPath.GetRaw(source.GetLocation())...)
	case DeviceSpec_FieldPathSelectorUsbGuard:
		values = append(values, fps.subPath.GetRaw(source.GetUsbGuard())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Device_Spec
func (fps *DeviceSpec_FieldSubPath) GetSingle(source *Device_Spec) (interface{}, bool) {
	switch fps.selector {
	case DeviceSpec_FieldPathSelectorSshConfig:
		if source.GetSshConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSshConfig())
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		if source.GetAttestationConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAttestationConfig())
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		if source.GetLoggingConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetLoggingConfig())
	case DeviceSpec_FieldPathSelectorProxyConfig:
		if source.GetProxyConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProxyConfig())
	case DeviceSpec_FieldPathSelectorLocation:
		if source.GetLocation() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetLocation())
	case DeviceSpec_FieldPathSelectorUsbGuard:
		if source.GetUsbGuard() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetUsbGuard())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fps.selector))
	}
}

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

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

func (fps *DeviceSpec_FieldSubPath) ClearValue(item *Device_Spec) {
	if item != nil {
		switch fps.selector {
		case DeviceSpec_FieldPathSelectorSshConfig:
			fps.subPath.ClearValueRaw(item.SshConfig)
		case DeviceSpec_FieldPathSelectorAttestationConfig:
			fps.subPath.ClearValueRaw(item.AttestationConfig)
		case DeviceSpec_FieldPathSelectorLoggingConfig:
			fps.subPath.ClearValueRaw(item.LoggingConfig)
		case DeviceSpec_FieldPathSelectorProxyConfig:
			fps.subPath.ClearValueRaw(item.ProxyConfig)
		case DeviceSpec_FieldPathSelectorLocation:
			fps.subPath.ClearValueRaw(item.Location)
		case DeviceSpec_FieldPathSelectorUsbGuard:
			fps.subPath.ClearValueRaw(item.UsbGuard)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fps.selector))
		}
	}
}

func (fps *DeviceSpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Spec))
}

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

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

func (fps *DeviceSpec_FieldSubPath) WithIValue(value interface{}) DeviceSpec_FieldPathValue {
	return &DeviceSpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceSpec_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceSpec_FieldPathArrayOfValues {
	return &DeviceSpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceSpec_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceSpec_FieldPathArrayItemValue {
	return &DeviceSpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceSpec_FieldPathValue allows storing values for Spec fields according to their type
type DeviceSpec_FieldPathValue interface {
	DeviceSpec_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec)
	CompareWith(*Device_Spec) (cmp int, comparable bool)
}

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

func MustParseDeviceSpec_FieldPathValue(pathStr, valueStr string) DeviceSpec_FieldPathValue {
	fpv, err := ParseDeviceSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpec_FieldTerminalPathValue struct {
	DeviceSpec_FieldTerminalPath
	value interface{}
}

var _ DeviceSpec_FieldPathValue = (*DeviceSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Spec' as interface{}
func (fpv *DeviceSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsServiceAccountValue() (*iam_service_account.Reference, bool) {
	res, ok := fpv.value.(*iam_service_account.Reference)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsLogBucketValue() (*logging_bucket.Reference, bool) {
	res, ok := fpv.value.(*logging_bucket.Reference)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsMetricsBucketValue() (*monitoring_bucket.Reference, bool) {
	res, ok := fpv.value.(*monitoring_bucket.Reference)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsOsVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsNetplanYamlConfigValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsNetplanApiConfigModeValue() (Device_Spec_NetworkConfigMode, bool) {
	res, ok := fpv.value.(Device_Spec_NetworkConfigMode)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsOsImageUrlValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsSshConfigValue() (*Device_Spec_SSHConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_SSHConfig)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsAttestationConfigValue() (*Device_Spec_AttestationConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_AttestationConfig)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsDisableDeviceDiscoveryValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsLoggingConfigValue() (*Device_Spec_LoggingConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_LoggingConfig)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsProxyConfigValue() (*Device_Spec_ProxyConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_ProxyConfig)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsLocationValue() (*Device_Spec_Location, bool) {
	res, ok := fpv.value.(*Device_Spec_Location)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsUsbGuardValue() (*Device_Spec_USBGuard, bool) {
	res, ok := fpv.value.(*Device_Spec_USBGuard)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsHealthChecksValue() ([]*api.HealthCheckSpec, bool) {
	res, ok := fpv.value.([]*api.HealthCheckSpec)
	return res, ok
}
func (fpv *DeviceSpec_FieldTerminalPathValue) AsDisableNetworkConfigFallbackValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object Spec
func (fpv *DeviceSpec_FieldTerminalPathValue) SetTo(target **Device_Spec) {
	if *target == nil {
		*target = new(Device_Spec)
	}
	switch fpv.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		(*target).ServiceAccount = fpv.value.(*iam_service_account.Reference)
	case DeviceSpec_FieldPathSelectorLogBucket:
		(*target).LogBucket = fpv.value.(*logging_bucket.Reference)
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		(*target).MetricsBucket = fpv.value.(*monitoring_bucket.Reference)
	case DeviceSpec_FieldPathSelectorOsVersion:
		(*target).OsVersion = fpv.value.(string)
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		(*target).NetplanYamlConfig = fpv.value.(string)
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		(*target).NetplanApiConfigMode = fpv.value.(Device_Spec_NetworkConfigMode)
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		(*target).OsImageUrl = fpv.value.(string)
	case DeviceSpec_FieldPathSelectorSshConfig:
		(*target).SshConfig = fpv.value.(*Device_Spec_SSHConfig)
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		(*target).AttestationConfig = fpv.value.(*Device_Spec_AttestationConfig)
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		(*target).DisableDeviceDiscovery = fpv.value.(bool)
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		(*target).LoggingConfig = fpv.value.(*Device_Spec_LoggingConfig)
	case DeviceSpec_FieldPathSelectorProxyConfig:
		(*target).ProxyConfig = fpv.value.(*Device_Spec_ProxyConfig)
	case DeviceSpec_FieldPathSelectorLocation:
		(*target).Location = fpv.value.(*Device_Spec_Location)
	case DeviceSpec_FieldPathSelectorUsbGuard:
		(*target).UsbGuard = fpv.value.(*Device_Spec_USBGuard)
	case DeviceSpec_FieldPathSelectorHealthChecks:
		(*target).HealthChecks = fpv.value.([]*api.HealthCheckSpec)
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		(*target).DisableNetworkConfigFallback = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpec_FieldTerminalPathValue' with the value under path in 'Device_Spec'.
func (fpv *DeviceSpec_FieldTerminalPathValue) CompareWith(source *Device_Spec) (int, bool) {
	switch fpv.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		leftValue := fpv.value.(*iam_service_account.Reference)
		rightValue := source.GetServiceAccount()
		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 DeviceSpec_FieldPathSelectorLogBucket:
		leftValue := fpv.value.(*logging_bucket.Reference)
		rightValue := source.GetLogBucket()
		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 DeviceSpec_FieldPathSelectorMetricsBucket:
		leftValue := fpv.value.(*monitoring_bucket.Reference)
		rightValue := source.GetMetricsBucket()
		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 DeviceSpec_FieldPathSelectorOsVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetOsVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		leftValue := fpv.value.(string)
		rightValue := source.GetNetplanYamlConfig()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		leftValue := fpv.value.(Device_Spec_NetworkConfigMode)
		rightValue := source.GetNetplanApiConfigMode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		leftValue := fpv.value.(string)
		rightValue := source.GetOsImageUrl()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpec_FieldPathSelectorSshConfig:
		return 0, false
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return 0, false
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		leftValue := fpv.value.(bool)
		rightValue := source.GetDisableDeviceDiscovery()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return 0, false
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return 0, false
	case DeviceSpec_FieldPathSelectorLocation:
		return 0, false
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return 0, false
	case DeviceSpec_FieldPathSelectorHealthChecks:
		return 0, false
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		leftValue := fpv.value.(bool)
		rightValue := source.GetDisableNetworkConfigFallback()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fpv.selector))
	}
}

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

type DeviceSpec_FieldSubPathValue struct {
	DeviceSpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceSpec_FieldPathValue = (*DeviceSpec_FieldSubPathValue)(nil)

func (fpvs *DeviceSpec_FieldSubPathValue) AsSshConfigPathValue() (DeviceSpecSSHConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecSSHConfig_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceSpec_FieldSubPathValue) AsAttestationConfigPathValue() (DeviceSpecAttestationConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecAttestationConfig_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceSpec_FieldSubPathValue) AsLoggingConfigPathValue() (DeviceSpecLoggingConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecLoggingConfig_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceSpec_FieldSubPathValue) AsProxyConfigPathValue() (DeviceSpecProxyConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceSpec_FieldSubPathValue) AsLocationPathValue() (DeviceSpecLocation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecLocation_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceSpec_FieldSubPathValue) AsUsbGuardPathValue() (DeviceSpecUSBGuard_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecUSBGuard_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceSpec_FieldSubPathValue) SetTo(target **Device_Spec) {
	if *target == nil {
		*target = new(Device_Spec)
	}
	switch fpvs.Selector() {
	case DeviceSpec_FieldPathSelectorSshConfig:
		fpvs.subPathValue.(DeviceSpecSSHConfig_FieldPathValue).SetTo(&(*target).SshConfig)
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		fpvs.subPathValue.(DeviceSpecAttestationConfig_FieldPathValue).SetTo(&(*target).AttestationConfig)
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		fpvs.subPathValue.(DeviceSpecLoggingConfig_FieldPathValue).SetTo(&(*target).LoggingConfig)
	case DeviceSpec_FieldPathSelectorProxyConfig:
		fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).SetTo(&(*target).ProxyConfig)
	case DeviceSpec_FieldPathSelectorLocation:
		fpvs.subPathValue.(DeviceSpecLocation_FieldPathValue).SetTo(&(*target).Location)
	case DeviceSpec_FieldPathSelectorUsbGuard:
		fpvs.subPathValue.(DeviceSpecUSBGuard_FieldPathValue).SetTo(&(*target).UsbGuard)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceSpec_FieldSubPathValue) CompareWith(source *Device_Spec) (int, bool) {
	switch fpvs.Selector() {
	case DeviceSpec_FieldPathSelectorSshConfig:
		return fpvs.subPathValue.(DeviceSpecSSHConfig_FieldPathValue).CompareWith(source.GetSshConfig())
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return fpvs.subPathValue.(DeviceSpecAttestationConfig_FieldPathValue).CompareWith(source.GetAttestationConfig())
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return fpvs.subPathValue.(DeviceSpecLoggingConfig_FieldPathValue).CompareWith(source.GetLoggingConfig())
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).CompareWith(source.GetProxyConfig())
	case DeviceSpec_FieldPathSelectorLocation:
		return fpvs.subPathValue.(DeviceSpecLocation_FieldPathValue).CompareWith(source.GetLocation())
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return fpvs.subPathValue.(DeviceSpecUSBGuard_FieldPathValue).CompareWith(source.GetUsbGuard())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceSpec_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpec_FieldTerminalPathArrayItemValue struct {
	DeviceSpec_FieldTerminalPath
	value interface{}
}

var _ DeviceSpec_FieldPathArrayItemValue = (*DeviceSpec_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec as interface{}
func (fpaiv *DeviceSpec_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpec_FieldTerminalPathArrayItemValue) AsHealthChecksItemValue() (*api.HealthCheckSpec, bool) {
	res, ok := fpaiv.value.(*api.HealthCheckSpec)
	return res, ok
}

func (fpaiv *DeviceSpec_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Spec'
func (fpaiv *DeviceSpec_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Spec) bool {
	slice := fpaiv.DeviceSpec_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 DeviceSpec_FieldSubPathArrayItemValue struct {
	DeviceSpec_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) AsSshConfigPathItemValue() (DeviceSpecSSHConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecSSHConfig_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) AsAttestationConfigPathItemValue() (DeviceSpecAttestationConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecAttestationConfig_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) AsLoggingConfigPathItemValue() (DeviceSpecLoggingConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecLoggingConfig_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) AsProxyConfigPathItemValue() (DeviceSpecProxyConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) AsLocationPathItemValue() (DeviceSpecLocation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecLocation_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) AsUsbGuardPathItemValue() (DeviceSpecUSBGuard_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecUSBGuard_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Spec'
func (fpaivs *DeviceSpec_FieldSubPathArrayItemValue) ContainsValue(source *Device_Spec) bool {
	switch fpaivs.Selector() {
	case DeviceSpec_FieldPathSelectorSshConfig:
		return fpaivs.subPathItemValue.(DeviceSpecSSHConfig_FieldPathArrayItemValue).ContainsValue(source.GetSshConfig())
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		return fpaivs.subPathItemValue.(DeviceSpecAttestationConfig_FieldPathArrayItemValue).ContainsValue(source.GetAttestationConfig())
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		return fpaivs.subPathItemValue.(DeviceSpecLoggingConfig_FieldPathArrayItemValue).ContainsValue(source.GetLoggingConfig())
	case DeviceSpec_FieldPathSelectorProxyConfig:
		return fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue).ContainsValue(source.GetProxyConfig())
	case DeviceSpec_FieldPathSelectorLocation:
		return fpaivs.subPathItemValue.(DeviceSpecLocation_FieldPathArrayItemValue).ContainsValue(source.GetLocation())
	case DeviceSpec_FieldPathSelectorUsbGuard:
		return fpaivs.subPathItemValue.(DeviceSpecUSBGuard_FieldPathArrayItemValue).ContainsValue(source.GetUsbGuard())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec: %d", fpaivs.Selector()))
	}
}

// DeviceSpec_FieldPathArrayOfValues allows storing slice of values for Spec fields according to their type
type DeviceSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpec_FieldPath
}

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

func MustParseDeviceSpec_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpec_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpec_FieldTerminalPathArrayOfValues struct {
	DeviceSpec_FieldTerminalPath
	values interface{}
}

var _ DeviceSpec_FieldPathArrayOfValues = (*DeviceSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpec_FieldPathSelectorServiceAccount:
		for _, v := range fpaov.values.([]*iam_service_account.Reference) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorLogBucket:
		for _, v := range fpaov.values.([]*logging_bucket.Reference) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorMetricsBucket:
		for _, v := range fpaov.values.([]*monitoring_bucket.Reference) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorOsVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorNetplanYamlConfig:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorNetplanApiConfigMode:
		for _, v := range fpaov.values.([]Device_Spec_NetworkConfigMode) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorOsImageUrl:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorSshConfig:
		for _, v := range fpaov.values.([]*Device_Spec_SSHConfig) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorAttestationConfig:
		for _, v := range fpaov.values.([]*Device_Spec_AttestationConfig) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorDisableDeviceDiscovery:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorLoggingConfig:
		for _, v := range fpaov.values.([]*Device_Spec_LoggingConfig) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorProxyConfig:
		for _, v := range fpaov.values.([]*Device_Spec_ProxyConfig) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorLocation:
		for _, v := range fpaov.values.([]*Device_Spec_Location) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorUsbGuard:
		for _, v := range fpaov.values.([]*Device_Spec_USBGuard) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorHealthChecks:
		for _, v := range fpaov.values.([][]*api.HealthCheckSpec) {
			values = append(values, v)
		}
	case DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsServiceAccountArrayOfValues() ([]*iam_service_account.Reference, bool) {
	res, ok := fpaov.values.([]*iam_service_account.Reference)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsLogBucketArrayOfValues() ([]*logging_bucket.Reference, bool) {
	res, ok := fpaov.values.([]*logging_bucket.Reference)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsMetricsBucketArrayOfValues() ([]*monitoring_bucket.Reference, bool) {
	res, ok := fpaov.values.([]*monitoring_bucket.Reference)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsOsVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsNetplanYamlConfigArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsNetplanApiConfigModeArrayOfValues() ([]Device_Spec_NetworkConfigMode, bool) {
	res, ok := fpaov.values.([]Device_Spec_NetworkConfigMode)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsOsImageUrlArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsSshConfigArrayOfValues() ([]*Device_Spec_SSHConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_SSHConfig)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsAttestationConfigArrayOfValues() ([]*Device_Spec_AttestationConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_AttestationConfig)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsDisableDeviceDiscoveryArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsLoggingConfigArrayOfValues() ([]*Device_Spec_LoggingConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_LoggingConfig)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsProxyConfigArrayOfValues() ([]*Device_Spec_ProxyConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_ProxyConfig)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsLocationArrayOfValues() ([]*Device_Spec_Location, bool) {
	res, ok := fpaov.values.([]*Device_Spec_Location)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsUsbGuardArrayOfValues() ([]*Device_Spec_USBGuard, bool) {
	res, ok := fpaov.values.([]*Device_Spec_USBGuard)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsHealthChecksArrayOfValues() ([][]*api.HealthCheckSpec, bool) {
	res, ok := fpaov.values.([][]*api.HealthCheckSpec)
	return res, ok
}
func (fpaov *DeviceSpec_FieldTerminalPathArrayOfValues) AsDisableNetworkConfigFallbackArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type DeviceSpec_FieldSubPathArrayOfValues struct {
	DeviceSpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceSpec_FieldPathArrayOfValues = (*DeviceSpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) AsSshConfigPathArrayOfValues() (DeviceSpecSSHConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecSSHConfig_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) AsAttestationConfigPathArrayOfValues() (DeviceSpecAttestationConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecAttestationConfig_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) AsLoggingConfigPathArrayOfValues() (DeviceSpecLoggingConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecLoggingConfig_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) AsProxyConfigPathArrayOfValues() (DeviceSpecProxyConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecProxyConfig_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) AsLocationPathArrayOfValues() (DeviceSpecLocation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecLocation_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceSpec_FieldSubPathArrayOfValues) AsUsbGuardPathArrayOfValues() (DeviceSpecUSBGuard_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecUSBGuard_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatus_FieldPathSelector int32

const (
	DeviceStatus_FieldPathSelectorAddresses                  DeviceStatus_FieldPathSelector = 0
	DeviceStatus_FieldPathSelectorConditions                 DeviceStatus_FieldPathSelector = 1
	DeviceStatus_FieldPathSelectorNetworkConfigState         DeviceStatus_FieldPathSelector = 2
	DeviceStatus_FieldPathSelectorProxyConfigStatus          DeviceStatus_FieldPathSelector = 3
	DeviceStatus_FieldPathSelectorDeviceInfo                 DeviceStatus_FieldPathSelector = 4
	DeviceStatus_FieldPathSelectorAttestationStatus          DeviceStatus_FieldPathSelector = 5
	DeviceStatus_FieldPathSelectorNormalizedAddress          DeviceStatus_FieldPathSelector = 6
	DeviceStatus_FieldPathSelectorConnectionStatus           DeviceStatus_FieldPathSelector = 7
	DeviceStatus_FieldPathSelectorConnectionStatusChangeTime DeviceStatus_FieldPathSelector = 8
)

func (s DeviceStatus_FieldPathSelector) String() string {
	switch s {
	case DeviceStatus_FieldPathSelectorAddresses:
		return "addresses"
	case DeviceStatus_FieldPathSelectorConditions:
		return "conditions"
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return "network_config_state"
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return "proxy_config_status"
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return "device_info"
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return "attestation_status"
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return "normalized_address"
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		return "connection_status"
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		return "connection_status_change_time"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", s))
	}
}

func BuildDeviceStatus_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatus_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "addresses":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorAddresses}, nil
		case "conditions":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConditions}, nil
		case "network_config_state", "networkConfigState", "network-config-state":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorNetworkConfigState}, nil
		case "proxy_config_status", "proxyConfigStatus", "proxy-config-status":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorProxyConfigStatus}, nil
		case "device_info", "deviceInfo", "device-info":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorDeviceInfo}, nil
		case "attestation_status", "attestationStatus", "attestation-status":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorAttestationStatus}, nil
		case "normalized_address", "normalizedAddress", "normalized-address":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorNormalizedAddress}, nil
		case "connection_status", "connectionStatus", "connection-status":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConnectionStatus}, nil
		case "connection_status_change_time", "connectionStatusChangeTime", "connection-status-change-time":
			return &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConnectionStatusChangeTime}, nil
		}
	} else {
		switch fp[0] {
		case "addresses":
			if subpath, err := BuildDeviceStatusAddress_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorAddresses, subPath: subpath}, nil
			}
		case "conditions":
			if subpath, err := BuildDeviceStatusCondition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorConditions, subPath: subpath}, nil
			}
		case "network_config_state", "networkConfigState", "network-config-state":
			if subpath, err := BuildDeviceStatusNetworkConfigState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorNetworkConfigState, subPath: subpath}, nil
			}
		case "proxy_config_status", "proxyConfigStatus", "proxy-config-status":
			if subpath, err := BuildDeviceStatusProxyConfigStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorProxyConfigStatus, subPath: subpath}, nil
			}
		case "device_info", "deviceInfo", "device-info":
			if subpath, err := BuildDeviceStatusDeviceInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorDeviceInfo, subPath: subpath}, nil
			}
		case "attestation_status", "attestationStatus", "attestation-status":
			if subpath, err := iam_iam_common.BuildPCR_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorAttestationStatus, subPath: subpath}, nil
			}
		case "normalized_address", "normalizedAddress", "normalized-address":
			if subpath, err := BuildDeviceStatusNormalizedAddress_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorNormalizedAddress, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status", fp)
}

func ParseDeviceStatus_FieldPath(rawField string) (DeviceStatus_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatus_FieldPath(fp)
}

func MustParseDeviceStatus_FieldPath(rawField string) DeviceStatus_FieldPath {
	fp, err := ParseDeviceStatus_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatus_FieldTerminalPath struct {
	selector DeviceStatus_FieldPathSelector
}

var _ DeviceStatus_FieldPath = (*DeviceStatus_FieldTerminalPath)(nil)

func (fp *DeviceStatus_FieldTerminalPath) Selector() DeviceStatus_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status
func (fp *DeviceStatus_FieldTerminalPath) Get(source *Device_Status) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatus_FieldPathSelectorAddresses:
			for _, value := range source.GetAddresses() {
				values = append(values, value)
			}
		case DeviceStatus_FieldPathSelectorConditions:
			for _, value := range source.GetConditions() {
				values = append(values, value)
			}
		case DeviceStatus_FieldPathSelectorNetworkConfigState:
			if source.NetworkConfigState != nil {
				values = append(values, source.NetworkConfigState)
			}
		case DeviceStatus_FieldPathSelectorProxyConfigStatus:
			if source.ProxyConfigStatus != nil {
				values = append(values, source.ProxyConfigStatus)
			}
		case DeviceStatus_FieldPathSelectorDeviceInfo:
			if source.DeviceInfo != nil {
				values = append(values, source.DeviceInfo)
			}
		case DeviceStatus_FieldPathSelectorAttestationStatus:
			for _, value := range source.GetAttestationStatus() {
				values = append(values, value)
			}
		case DeviceStatus_FieldPathSelectorNormalizedAddress:
			if source.NormalizedAddress != nil {
				values = append(values, source.NormalizedAddress)
			}
		case DeviceStatus_FieldPathSelectorConnectionStatus:
			values = append(values, source.ConnectionStatus)
		case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
			if source.ConnectionStatusChangeTime != nil {
				values = append(values, source.ConnectionStatusChangeTime)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status
func (fp *DeviceStatus_FieldTerminalPath) GetSingle(source *Device_Status) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		res := source.GetAddresses()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorConditions:
		res := source.GetConditions()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		res := source.GetNetworkConfigState()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		res := source.GetProxyConfigStatus()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		res := source.GetDeviceInfo()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		res := source.GetAttestationStatus()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		res := source.GetNormalizedAddress()
		return res, res != nil
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		return source.GetConnectionStatus(), source != nil
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		res := source.GetConnectionStatusChangeTime()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatus_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		return ([]*Device_Status_Address)(nil)
	case DeviceStatus_FieldPathSelectorConditions:
		return ([]*Device_Status_Condition)(nil)
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return (*Device_Status_NetworkConfigState)(nil)
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return (*Device_Status_ProxyConfigStatus)(nil)
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return (*Device_Status_DeviceInfo)(nil)
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return ([]*iam_iam_common.PCR)(nil)
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return (*Device_Status_NormalizedAddress)(nil)
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		return Device_Status_CONNECTION_STATUS_UNSPECIFIED
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
	}
}

func (fp *DeviceStatus_FieldTerminalPath) ClearValue(item *Device_Status) {
	if item != nil {
		switch fp.selector {
		case DeviceStatus_FieldPathSelectorAddresses:
			item.Addresses = nil
		case DeviceStatus_FieldPathSelectorConditions:
			item.Conditions = nil
		case DeviceStatus_FieldPathSelectorNetworkConfigState:
			item.NetworkConfigState = nil
		case DeviceStatus_FieldPathSelectorProxyConfigStatus:
			item.ProxyConfigStatus = nil
		case DeviceStatus_FieldPathSelectorDeviceInfo:
			item.DeviceInfo = nil
		case DeviceStatus_FieldPathSelectorAttestationStatus:
			item.AttestationStatus = nil
		case DeviceStatus_FieldPathSelectorNormalizedAddress:
			item.NormalizedAddress = nil
		case DeviceStatus_FieldPathSelectorConnectionStatus:
			item.ConnectionStatus = Device_Status_CONNECTION_STATUS_UNSPECIFIED
		case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
			item.ConnectionStatusChangeTime = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatus_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatus_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatus_FieldPathSelectorConnectionStatus ||
		fp.selector == DeviceStatus_FieldPathSelectorConnectionStatusChangeTime
}

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

func (fp *DeviceStatus_FieldTerminalPath) WithIValue(value interface{}) DeviceStatus_FieldPathValue {
	switch fp.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.([]*Device_Status_Address)}
	case DeviceStatus_FieldPathSelectorConditions:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.([]*Device_Status_Condition)}
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_NetworkConfigState)}
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_ProxyConfigStatus)}
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo)}
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.([]*iam_iam_common.PCR)}
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_NormalizedAddress)}
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(Device_Status_ConnectionStatus)}
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		return &DeviceStatus_FieldTerminalPathValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
	}
}

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

func (fp *DeviceStatus_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatus_FieldPathArrayOfValues {
	fpaov := &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([][]*Device_Status_Address)}
	case DeviceStatus_FieldPathSelectorConditions:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([][]*Device_Status_Condition)}
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([]*Device_Status_NetworkConfigState)}
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([]*Device_Status_ProxyConfigStatus)}
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo)}
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([][]*iam_iam_common.PCR)}
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([]*Device_Status_NormalizedAddress)}
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([]Device_Status_ConnectionStatus)}
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		return &DeviceStatus_FieldTerminalPathArrayOfValues{DeviceStatus_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceStatus_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatus_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		return &DeviceStatus_FieldTerminalPathArrayItemValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_Address)}
	case DeviceStatus_FieldPathSelectorConditions:
		return &DeviceStatus_FieldTerminalPathArrayItemValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_Condition)}
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return &DeviceStatus_FieldTerminalPathArrayItemValue{DeviceStatus_FieldTerminalPath: *fp, value: value.(*iam_iam_common.PCR)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fp.selector))
	}
}

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

type DeviceStatus_FieldSubPath struct {
	selector DeviceStatus_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatus_FieldPath = (*DeviceStatus_FieldSubPath)(nil)

func (fps *DeviceStatus_FieldSubPath) Selector() DeviceStatus_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatus_FieldSubPath) AsAddressesSubPath() (DeviceStatusAddress_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusAddress_FieldPath)
	return res, ok
}
func (fps *DeviceStatus_FieldSubPath) AsConditionsSubPath() (DeviceStatusCondition_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusCondition_FieldPath)
	return res, ok
}
func (fps *DeviceStatus_FieldSubPath) AsNetworkConfigStateSubPath() (DeviceStatusNetworkConfigState_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusNetworkConfigState_FieldPath)
	return res, ok
}
func (fps *DeviceStatus_FieldSubPath) AsProxyConfigStatusSubPath() (DeviceStatusProxyConfigStatus_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusProxyConfigStatus_FieldPath)
	return res, ok
}
func (fps *DeviceStatus_FieldSubPath) AsDeviceInfoSubPath() (DeviceStatusDeviceInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfo_FieldPath)
	return res, ok
}
func (fps *DeviceStatus_FieldSubPath) AsAttestationStatusSubPath() (iam_iam_common.PCR_FieldPath, bool) {
	res, ok := fps.subPath.(iam_iam_common.PCR_FieldPath)
	return res, ok
}
func (fps *DeviceStatus_FieldSubPath) AsNormalizedAddressSubPath() (DeviceStatusNormalizedAddress_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusNormalizedAddress_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Device_Status
func (fps *DeviceStatus_FieldSubPath) Get(source *Device_Status) (values []interface{}) {
	switch fps.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		for _, item := range source.GetAddresses() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case DeviceStatus_FieldPathSelectorConditions:
		for _, item := range source.GetConditions() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		values = append(values, fps.subPath.GetRaw(source.GetNetworkConfigState())...)
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		values = append(values, fps.subPath.GetRaw(source.GetProxyConfigStatus())...)
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		values = append(values, fps.subPath.GetRaw(source.GetDeviceInfo())...)
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		for _, item := range source.GetAttestationStatus() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		values = append(values, fps.subPath.GetRaw(source.GetNormalizedAddress())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Device_Status
func (fps *DeviceStatus_FieldSubPath) GetSingle(source *Device_Status) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		if len(source.GetAddresses()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAddresses()[0])
	case DeviceStatus_FieldPathSelectorConditions:
		if len(source.GetConditions()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetConditions()[0])
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		if source.GetNetworkConfigState() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNetworkConfigState())
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		if source.GetProxyConfigStatus() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProxyConfigStatus())
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		if source.GetDeviceInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDeviceInfo())
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		if len(source.GetAttestationStatus()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAttestationStatus()[0])
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		if source.GetNormalizedAddress() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNormalizedAddress())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fps.selector))
	}
}

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

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

func (fps *DeviceStatus_FieldSubPath) ClearValue(item *Device_Status) {
	if item != nil {
		switch fps.selector {
		case DeviceStatus_FieldPathSelectorAddresses:
			for _, subItem := range item.Addresses {
				fps.subPath.ClearValueRaw(subItem)
			}
		case DeviceStatus_FieldPathSelectorConditions:
			for _, subItem := range item.Conditions {
				fps.subPath.ClearValueRaw(subItem)
			}
		case DeviceStatus_FieldPathSelectorNetworkConfigState:
			fps.subPath.ClearValueRaw(item.NetworkConfigState)
		case DeviceStatus_FieldPathSelectorProxyConfigStatus:
			fps.subPath.ClearValueRaw(item.ProxyConfigStatus)
		case DeviceStatus_FieldPathSelectorDeviceInfo:
			fps.subPath.ClearValueRaw(item.DeviceInfo)
		case DeviceStatus_FieldPathSelectorAttestationStatus:
			for _, subItem := range item.AttestationStatus {
				fps.subPath.ClearValueRaw(subItem)
			}
		case DeviceStatus_FieldPathSelectorNormalizedAddress:
			fps.subPath.ClearValueRaw(item.NormalizedAddress)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatus_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status))
}

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

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

func (fps *DeviceStatus_FieldSubPath) WithIValue(value interface{}) DeviceStatus_FieldPathValue {
	return &DeviceStatus_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatus_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatus_FieldPathArrayOfValues {
	return &DeviceStatus_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatus_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatus_FieldPathArrayItemValue {
	return &DeviceStatus_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseDeviceStatus_FieldPathValue(pathStr, valueStr string) (DeviceStatus_FieldPathValue, error) {
	fp, err := ParseDeviceStatus_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Status field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatus_FieldPathValue), nil
}

func MustParseDeviceStatus_FieldPathValue(pathStr, valueStr string) DeviceStatus_FieldPathValue {
	fpv, err := ParseDeviceStatus_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatus_FieldTerminalPathValue struct {
	DeviceStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatus_FieldPathValue = (*DeviceStatus_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Status' as interface{}
func (fpv *DeviceStatus_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsAddressesValue() ([]*Device_Status_Address, bool) {
	res, ok := fpv.value.([]*Device_Status_Address)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsConditionsValue() ([]*Device_Status_Condition, bool) {
	res, ok := fpv.value.([]*Device_Status_Condition)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsNetworkConfigStateValue() (*Device_Status_NetworkConfigState, bool) {
	res, ok := fpv.value.(*Device_Status_NetworkConfigState)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsProxyConfigStatusValue() (*Device_Status_ProxyConfigStatus, bool) {
	res, ok := fpv.value.(*Device_Status_ProxyConfigStatus)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsDeviceInfoValue() (*Device_Status_DeviceInfo, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsAttestationStatusValue() ([]*iam_iam_common.PCR, bool) {
	res, ok := fpv.value.([]*iam_iam_common.PCR)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsNormalizedAddressValue() (*Device_Status_NormalizedAddress, bool) {
	res, ok := fpv.value.(*Device_Status_NormalizedAddress)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsConnectionStatusValue() (Device_Status_ConnectionStatus, bool) {
	res, ok := fpv.value.(Device_Status_ConnectionStatus)
	return res, ok
}
func (fpv *DeviceStatus_FieldTerminalPathValue) AsConnectionStatusChangeTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object Status
func (fpv *DeviceStatus_FieldTerminalPathValue) SetTo(target **Device_Status) {
	if *target == nil {
		*target = new(Device_Status)
	}
	switch fpv.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		(*target).Addresses = fpv.value.([]*Device_Status_Address)
	case DeviceStatus_FieldPathSelectorConditions:
		(*target).Conditions = fpv.value.([]*Device_Status_Condition)
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		(*target).NetworkConfigState = fpv.value.(*Device_Status_NetworkConfigState)
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		(*target).ProxyConfigStatus = fpv.value.(*Device_Status_ProxyConfigStatus)
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		(*target).DeviceInfo = fpv.value.(*Device_Status_DeviceInfo)
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		(*target).AttestationStatus = fpv.value.([]*iam_iam_common.PCR)
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		(*target).NormalizedAddress = fpv.value.(*Device_Status_NormalizedAddress)
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		(*target).ConnectionStatus = fpv.value.(Device_Status_ConnectionStatus)
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		(*target).ConnectionStatusChangeTime = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatus_FieldTerminalPathValue' with the value under path in 'Device_Status'.
func (fpv *DeviceStatus_FieldTerminalPathValue) CompareWith(source *Device_Status) (int, bool) {
	switch fpv.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		return 0, false
	case DeviceStatus_FieldPathSelectorConditions:
		return 0, false
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return 0, false
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return 0, false
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return 0, false
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return 0, false
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return 0, false
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		leftValue := fpv.value.(Device_Status_ConnectionStatus)
		rightValue := source.GetConnectionStatus()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetConnectionStatusChangeTime()
		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
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fpv.selector))
	}
}

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

type DeviceStatus_FieldSubPathValue struct {
	DeviceStatus_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatus_FieldPathValue = (*DeviceStatus_FieldSubPathValue)(nil)

func (fpvs *DeviceStatus_FieldSubPathValue) AsAddressesPathValue() (DeviceStatusAddress_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusAddress_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatus_FieldSubPathValue) AsConditionsPathValue() (DeviceStatusCondition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusCondition_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatus_FieldSubPathValue) AsNetworkConfigStatePathValue() (DeviceStatusNetworkConfigState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusNetworkConfigState_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatus_FieldSubPathValue) AsProxyConfigStatusPathValue() (DeviceStatusProxyConfigStatus_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusProxyConfigStatus_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatus_FieldSubPathValue) AsDeviceInfoPathValue() (DeviceStatusDeviceInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfo_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatus_FieldSubPathValue) AsAttestationStatusPathValue() (iam_iam_common.PCR_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(iam_iam_common.PCR_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatus_FieldSubPathValue) AsNormalizedAddressPathValue() (DeviceStatusNormalizedAddress_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusNormalizedAddress_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatus_FieldSubPathValue) SetTo(target **Device_Status) {
	if *target == nil {
		*target = new(Device_Status)
	}
	switch fpvs.Selector() {
	case DeviceStatus_FieldPathSelectorAddresses:
		panic("FieldPath setter is unsupported for array subpaths")
	case DeviceStatus_FieldPathSelectorConditions:
		panic("FieldPath setter is unsupported for array subpaths")
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		fpvs.subPathValue.(DeviceStatusNetworkConfigState_FieldPathValue).SetTo(&(*target).NetworkConfigState)
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		fpvs.subPathValue.(DeviceStatusProxyConfigStatus_FieldPathValue).SetTo(&(*target).ProxyConfigStatus)
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		fpvs.subPathValue.(DeviceStatusDeviceInfo_FieldPathValue).SetTo(&(*target).DeviceInfo)
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		panic("FieldPath setter is unsupported for array subpaths")
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		fpvs.subPathValue.(DeviceStatusNormalizedAddress_FieldPathValue).SetTo(&(*target).NormalizedAddress)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceStatus_FieldSubPathValue) CompareWith(source *Device_Status) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatus_FieldPathSelectorAddresses:
		return 0, false // repeated field
	case DeviceStatus_FieldPathSelectorConditions:
		return 0, false // repeated field
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return fpvs.subPathValue.(DeviceStatusNetworkConfigState_FieldPathValue).CompareWith(source.GetNetworkConfigState())
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return fpvs.subPathValue.(DeviceStatusProxyConfigStatus_FieldPathValue).CompareWith(source.GetProxyConfigStatus())
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return fpvs.subPathValue.(DeviceStatusDeviceInfo_FieldPathValue).CompareWith(source.GetDeviceInfo())
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return 0, false // repeated field
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return fpvs.subPathValue.(DeviceStatusNormalizedAddress_FieldPathValue).CompareWith(source.GetNormalizedAddress())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fpvs.Selector()))
	}
}

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

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

// ParseDeviceStatus_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatus_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatus_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatus_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Status field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatus_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatus_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatus_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatus_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatus_FieldTerminalPathArrayItemValue struct {
	DeviceStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatus_FieldPathArrayItemValue = (*DeviceStatus_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status as interface{}
func (fpaiv *DeviceStatus_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatus_FieldTerminalPathArrayItemValue) AsAddressesItemValue() (*Device_Status_Address, bool) {
	res, ok := fpaiv.value.(*Device_Status_Address)
	return res, ok
}
func (fpaiv *DeviceStatus_FieldTerminalPathArrayItemValue) AsConditionsItemValue() (*Device_Status_Condition, bool) {
	res, ok := fpaiv.value.(*Device_Status_Condition)
	return res, ok
}
func (fpaiv *DeviceStatus_FieldTerminalPathArrayItemValue) AsAttestationStatusItemValue() (*iam_iam_common.PCR, bool) {
	res, ok := fpaiv.value.(*iam_iam_common.PCR)
	return res, ok
}

func (fpaiv *DeviceStatus_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Status'
func (fpaiv *DeviceStatus_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status) bool {
	slice := fpaiv.DeviceStatus_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 DeviceStatus_FieldSubPathArrayItemValue struct {
	DeviceStatus_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsAddressesPathItemValue() (DeviceStatusAddress_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusAddress_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsConditionsPathItemValue() (DeviceStatusCondition_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusCondition_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsNetworkConfigStatePathItemValue() (DeviceStatusNetworkConfigState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusNetworkConfigState_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsProxyConfigStatusPathItemValue() (DeviceStatusProxyConfigStatus_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusProxyConfigStatus_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsDeviceInfoPathItemValue() (DeviceStatusDeviceInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsAttestationStatusPathItemValue() (iam_iam_common.PCR_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(iam_iam_common.PCR_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) AsNormalizedAddressPathItemValue() (DeviceStatusNormalizedAddress_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusNormalizedAddress_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Status'
func (fpaivs *DeviceStatus_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status) bool {
	switch fpaivs.Selector() {
	case DeviceStatus_FieldPathSelectorAddresses:
		return false // repeated/map field
	case DeviceStatus_FieldPathSelectorConditions:
		return false // repeated/map field
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		return fpaivs.subPathItemValue.(DeviceStatusNetworkConfigState_FieldPathArrayItemValue).ContainsValue(source.GetNetworkConfigState())
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		return fpaivs.subPathItemValue.(DeviceStatusProxyConfigStatus_FieldPathArrayItemValue).ContainsValue(source.GetProxyConfigStatus())
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfo_FieldPathArrayItemValue).ContainsValue(source.GetDeviceInfo())
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		return false // repeated/map field
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		return fpaivs.subPathItemValue.(DeviceStatusNormalizedAddress_FieldPathArrayItemValue).ContainsValue(source.GetNormalizedAddress())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status: %d", fpaivs.Selector()))
	}
}

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

func ParseDeviceStatus_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatus_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatus_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Status field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatus_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatus_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatus_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatus_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatus_FieldTerminalPathArrayOfValues struct {
	DeviceStatus_FieldTerminalPath
	values interface{}
}

var _ DeviceStatus_FieldPathArrayOfValues = (*DeviceStatus_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatus_FieldPathSelectorAddresses:
		for _, v := range fpaov.values.([][]*Device_Status_Address) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorConditions:
		for _, v := range fpaov.values.([][]*Device_Status_Condition) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorNetworkConfigState:
		for _, v := range fpaov.values.([]*Device_Status_NetworkConfigState) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorProxyConfigStatus:
		for _, v := range fpaov.values.([]*Device_Status_ProxyConfigStatus) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorDeviceInfo:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorAttestationStatus:
		for _, v := range fpaov.values.([][]*iam_iam_common.PCR) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorNormalizedAddress:
		for _, v := range fpaov.values.([]*Device_Status_NormalizedAddress) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorConnectionStatus:
		for _, v := range fpaov.values.([]Device_Status_ConnectionStatus) {
			values = append(values, v)
		}
	case DeviceStatus_FieldPathSelectorConnectionStatusChangeTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsAddressesArrayOfValues() ([][]*Device_Status_Address, bool) {
	res, ok := fpaov.values.([][]*Device_Status_Address)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsConditionsArrayOfValues() ([][]*Device_Status_Condition, bool) {
	res, ok := fpaov.values.([][]*Device_Status_Condition)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsNetworkConfigStateArrayOfValues() ([]*Device_Status_NetworkConfigState, bool) {
	res, ok := fpaov.values.([]*Device_Status_NetworkConfigState)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsProxyConfigStatusArrayOfValues() ([]*Device_Status_ProxyConfigStatus, bool) {
	res, ok := fpaov.values.([]*Device_Status_ProxyConfigStatus)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsDeviceInfoArrayOfValues() ([]*Device_Status_DeviceInfo, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsAttestationStatusArrayOfValues() ([][]*iam_iam_common.PCR, bool) {
	res, ok := fpaov.values.([][]*iam_iam_common.PCR)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsNormalizedAddressArrayOfValues() ([]*Device_Status_NormalizedAddress, bool) {
	res, ok := fpaov.values.([]*Device_Status_NormalizedAddress)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsConnectionStatusArrayOfValues() ([]Device_Status_ConnectionStatus, bool) {
	res, ok := fpaov.values.([]Device_Status_ConnectionStatus)
	return res, ok
}
func (fpaov *DeviceStatus_FieldTerminalPathArrayOfValues) AsConnectionStatusChangeTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

type DeviceStatus_FieldSubPathArrayOfValues struct {
	DeviceStatus_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatus_FieldPathArrayOfValues = (*DeviceStatus_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsAddressesPathArrayOfValues() (DeviceStatusAddress_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusAddress_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsConditionsPathArrayOfValues() (DeviceStatusCondition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusCondition_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsNetworkConfigStatePathArrayOfValues() (DeviceStatusNetworkConfigState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusNetworkConfigState_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsProxyConfigStatusPathArrayOfValues() (DeviceStatusProxyConfigStatus_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusProxyConfigStatus_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsDeviceInfoPathArrayOfValues() (DeviceStatusDeviceInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsAttestationStatusPathArrayOfValues() (iam_iam_common.PCR_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(iam_iam_common.PCR_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatus_FieldSubPathArrayOfValues) AsNormalizedAddressPathArrayOfValues() (DeviceStatusNormalizedAddress_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusNormalizedAddress_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DevicePublicListingSpec_FieldPathSelector int32

const (
	DevicePublicListingSpec_FieldPathSelectorEnabled   DevicePublicListingSpec_FieldPathSelector = 0
	DevicePublicListingSpec_FieldPathSelectorFieldMask DevicePublicListingSpec_FieldPathSelector = 1
)

func (s DevicePublicListingSpec_FieldPathSelector) String() string {
	switch s {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		return "enabled"
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", s))
	}
}

func BuildDevicePublicListingSpec_FieldPath(fp gotenobject.RawFieldPath) (DevicePublicListingSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_PublicListingSpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "enabled":
			return &DevicePublicListingSpec_FieldTerminalPath{selector: DevicePublicListingSpec_FieldPathSelectorEnabled}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &DevicePublicListingSpec_FieldTerminalPath{selector: DevicePublicListingSpec_FieldPathSelectorFieldMask}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_PublicListingSpec", fp)
}

func ParseDevicePublicListingSpec_FieldPath(rawField string) (DevicePublicListingSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDevicePublicListingSpec_FieldPath(fp)
}

func MustParseDevicePublicListingSpec_FieldPath(rawField string) DevicePublicListingSpec_FieldPath {
	fp, err := ParseDevicePublicListingSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DevicePublicListingSpec_FieldTerminalPath struct {
	selector DevicePublicListingSpec_FieldPathSelector
}

var _ DevicePublicListingSpec_FieldPath = (*DevicePublicListingSpec_FieldTerminalPath)(nil)

func (fp *DevicePublicListingSpec_FieldTerminalPath) Selector() DevicePublicListingSpec_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *DevicePublicListingSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		return false
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		return (*Device_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", fp.selector))
	}
}

func (fp *DevicePublicListingSpec_FieldTerminalPath) ClearValue(item *Device_PublicListingSpec) {
	if item != nil {
		switch fp.selector {
		case DevicePublicListingSpec_FieldPathSelectorEnabled:
			item.Enabled = false
		case DevicePublicListingSpec_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", fp.selector))
		}
	}
}

func (fp *DevicePublicListingSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_PublicListingSpec))
}

// IsLeaf - whether field path is holds simple value
func (fp *DevicePublicListingSpec_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DevicePublicListingSpec_FieldPathSelectorEnabled ||
		fp.selector == DevicePublicListingSpec_FieldPathSelectorFieldMask
}

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

func (fp *DevicePublicListingSpec_FieldTerminalPath) WithIValue(value interface{}) DevicePublicListingSpec_FieldPathValue {
	switch fp.selector {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		return &DevicePublicListingSpec_FieldTerminalPathValue{DevicePublicListingSpec_FieldTerminalPath: *fp, value: value.(bool)}
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		return &DevicePublicListingSpec_FieldTerminalPathValue{DevicePublicListingSpec_FieldTerminalPath: *fp, value: value.(*Device_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", fp.selector))
	}
}

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

func (fp *DevicePublicListingSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) DevicePublicListingSpec_FieldPathArrayOfValues {
	fpaov := &DevicePublicListingSpec_FieldTerminalPathArrayOfValues{DevicePublicListingSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		return &DevicePublicListingSpec_FieldTerminalPathArrayOfValues{DevicePublicListingSpec_FieldTerminalPath: *fp, values: values.([]bool)}
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		return &DevicePublicListingSpec_FieldTerminalPathArrayOfValues{DevicePublicListingSpec_FieldTerminalPath: *fp, values: values.([]*Device_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DevicePublicListingSpec_FieldPathValue allows storing values for PublicListingSpec fields according to their type
type DevicePublicListingSpec_FieldPathValue interface {
	DevicePublicListingSpec_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_PublicListingSpec)
	CompareWith(*Device_PublicListingSpec) (cmp int, comparable bool)
}

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

func MustParseDevicePublicListingSpec_FieldPathValue(pathStr, valueStr string) DevicePublicListingSpec_FieldPathValue {
	fpv, err := ParseDevicePublicListingSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DevicePublicListingSpec_FieldTerminalPathValue struct {
	DevicePublicListingSpec_FieldTerminalPath
	value interface{}
}

var _ DevicePublicListingSpec_FieldPathValue = (*DevicePublicListingSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PublicListingSpec' as interface{}
func (fpv *DevicePublicListingSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DevicePublicListingSpec_FieldTerminalPathValue) AsEnabledValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DevicePublicListingSpec_FieldTerminalPathValue) AsFieldMaskValue() (*Device_FieldMask, bool) {
	res, ok := fpv.value.(*Device_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object PublicListingSpec
func (fpv *DevicePublicListingSpec_FieldTerminalPathValue) SetTo(target **Device_PublicListingSpec) {
	if *target == nil {
		*target = new(Device_PublicListingSpec)
	}
	switch fpv.selector {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		(*target).Enabled = fpv.value.(bool)
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*Device_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DevicePublicListingSpec_FieldTerminalPathValue' with the value under path in 'Device_PublicListingSpec'.
func (fpv *DevicePublicListingSpec_FieldTerminalPathValue) CompareWith(source *Device_PublicListingSpec) (int, bool) {
	switch fpv.selector {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnabled()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_PublicListingSpec: %d", fpv.selector))
	}
}

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

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

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

func MustParseDevicePublicListingSpec_FieldPathArrayItemValue(pathStr, valueStr string) DevicePublicListingSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseDevicePublicListingSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DevicePublicListingSpec_FieldTerminalPathArrayItemValue struct {
	DevicePublicListingSpec_FieldTerminalPath
	value interface{}
}

var _ DevicePublicListingSpec_FieldPathArrayItemValue = (*DevicePublicListingSpec_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DevicePublicListingSpec_FieldTerminalPathArrayItemValue) GetSingle(source *Device_PublicListingSpec) (interface{}, bool) {
	return nil, false
}

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

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

// DevicePublicListingSpec_FieldPathArrayOfValues allows storing slice of values for PublicListingSpec fields according to their type
type DevicePublicListingSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DevicePublicListingSpec_FieldPath
}

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

func MustParseDevicePublicListingSpec_FieldPathArrayOfValues(pathStr, valuesStr string) DevicePublicListingSpec_FieldPathArrayOfValues {
	fpaov, err := ParseDevicePublicListingSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DevicePublicListingSpec_FieldTerminalPathArrayOfValues struct {
	DevicePublicListingSpec_FieldTerminalPath
	values interface{}
}

var _ DevicePublicListingSpec_FieldPathArrayOfValues = (*DevicePublicListingSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DevicePublicListingSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DevicePublicListingSpec_FieldPathSelectorEnabled:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DevicePublicListingSpec_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*Device_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DevicePublicListingSpec_FieldTerminalPathArrayOfValues) AsEnabledArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DevicePublicListingSpec_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*Device_FieldMask, bool) {
	res, ok := fpaov.values.([]*Device_FieldMask)
	return res, ok
}

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

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

type DeviceSpecSSHConfig_FieldPathSelector int32

const (
	DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer   DeviceSpecSSHConfig_FieldPathSelector = 0
	DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword DeviceSpecSSHConfig_FieldPathSelector = 1
	DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized      DeviceSpecSSHConfig_FieldPathSelector = 2
	DeviceSpecSSHConfig_FieldPathSelectorIpAllowList        DeviceSpecSSHConfig_FieldPathSelector = 3
	DeviceSpecSSHConfig_FieldPathSelectorIpDenyList         DeviceSpecSSHConfig_FieldPathSelector = 4
	DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod       DeviceSpecSSHConfig_FieldPathSelector = 5
	DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey  DeviceSpecSSHConfig_FieldPathSelector = 6
)

func (s DeviceSpecSSHConfig_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		return "disable_ssh_server"
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		return "disable_ssh_password"
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		return "ssh_authorized"
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		return "ip_allow_list"
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		return "ip_deny_list"
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		return "reject_period"
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		return "disable_ssh_authkey"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", s))
	}
}

func BuildDeviceSpecSSHConfig_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecSSHConfig_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_SSHConfig")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "disable_ssh_server", "disableSshServer", "disable-ssh-server":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer}, nil
		case "disable_ssh_password", "disableSshPassword", "disable-ssh-password":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword}, nil
		case "ssh_authorized", "sshAuthorized", "ssh-authorized":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized}, nil
		case "ip_allow_list", "ipAllowList", "ip-allow-list":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorIpAllowList}, nil
		case "ip_deny_list", "ipDenyList", "ip-deny-list":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorIpDenyList}, nil
		case "reject_period", "rejectPeriod", "reject-period":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod}, nil
		case "disable_ssh_authkey", "disableSshAuthkey", "disable-ssh-authkey":
			return &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey}, nil
		}
	} else {
		switch fp[0] {
		case "ssh_authorized", "sshAuthorized", "ssh-authorized":
			if subpath, err := BuildDeviceSpecSSHConfigAuthKey_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpecSSHConfig_FieldSubPath{selector: DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_SSHConfig", fp)
}

func ParseDeviceSpecSSHConfig_FieldPath(rawField string) (DeviceSpecSSHConfig_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecSSHConfig_FieldPath(fp)
}

func MustParseDeviceSpecSSHConfig_FieldPath(rawField string) DeviceSpecSSHConfig_FieldPath {
	fp, err := ParseDeviceSpecSSHConfig_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecSSHConfig_FieldTerminalPath struct {
	selector DeviceSpecSSHConfig_FieldPathSelector
}

var _ DeviceSpecSSHConfig_FieldPath = (*DeviceSpecSSHConfig_FieldTerminalPath)(nil)

func (fp *DeviceSpecSSHConfig_FieldTerminalPath) Selector() DeviceSpecSSHConfig_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Spec_SSHConfig
func (fp *DeviceSpecSSHConfig_FieldTerminalPath) Get(source *Device_Spec_SSHConfig) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
			values = append(values, source.DisableSshServer)
		case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
			values = append(values, source.DisableSshPassword)
		case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
			for _, value := range source.GetSshAuthorized() {
				values = append(values, value)
			}
		case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
			for _, value := range source.GetIpAllowList() {
				values = append(values, value)
			}
		case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
			for _, value := range source.GetIpDenyList() {
				values = append(values, value)
			}
		case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
			if source.RejectPeriod != nil {
				values = append(values, source.RejectPeriod)
			}
		case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
			values = append(values, source.DisableSshAuthkey)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Spec_SSHConfig
func (fp *DeviceSpecSSHConfig_FieldTerminalPath) GetSingle(source *Device_Spec_SSHConfig) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		return source.GetDisableSshServer(), source != nil
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		return source.GetDisableSshPassword(), source != nil
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		res := source.GetSshAuthorized()
		return res, res != nil
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		res := source.GetIpAllowList()
		return res, res != nil
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		res := source.GetIpDenyList()
		return res, res != nil
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		res := source.GetRejectPeriod()
		return res, res != nil
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		return source.GetDisableSshAuthkey(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecSSHConfig_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		return false
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		return false
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		return ([]*Device_Spec_SSHConfig_AuthKey)(nil)
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		return ([]string)(nil)
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		return ([]string)(nil)
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		return (*durationpb.Duration)(nil)
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
	}
}

func (fp *DeviceSpecSSHConfig_FieldTerminalPath) ClearValue(item *Device_Spec_SSHConfig) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
			item.DisableSshServer = false
		case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
			item.DisableSshPassword = false
		case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
			item.SshAuthorized = nil
		case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
			item.IpAllowList = nil
		case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
			item.IpDenyList = nil
		case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
			item.RejectPeriod = nil
		case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
			item.DisableSshAuthkey = false
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecSSHConfig_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_SSHConfig))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecSSHConfig_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer ||
		fp.selector == DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword ||
		fp.selector == DeviceSpecSSHConfig_FieldPathSelectorIpAllowList ||
		fp.selector == DeviceSpecSSHConfig_FieldPathSelectorIpDenyList ||
		fp.selector == DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod ||
		fp.selector == DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey
}

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

func (fp *DeviceSpecSSHConfig_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecSSHConfig_FieldPathValue {
	switch fp.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.([]*Device_Spec_SSHConfig_AuthKey)}
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		return &DeviceSpecSSHConfig_FieldTerminalPathValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecSSHConfig_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecSSHConfig_FieldPathArrayOfValues {
	fpaov := &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([][]*Device_Spec_SSHConfig_AuthKey)}
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpecSSHConfig_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpecSSHConfig_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(*Device_Spec_SSHConfig_AuthKey)}
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		return &DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue{DeviceSpecSSHConfig_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fp.selector))
	}
}

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

type DeviceSpecSSHConfig_FieldSubPath struct {
	selector DeviceSpecSSHConfig_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceSpecSSHConfig_FieldPath = (*DeviceSpecSSHConfig_FieldSubPath)(nil)

func (fps *DeviceSpecSSHConfig_FieldSubPath) Selector() DeviceSpecSSHConfig_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceSpecSSHConfig_FieldSubPath) AsSshAuthorizedSubPath() (DeviceSpecSSHConfigAuthKey_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecSSHConfigAuthKey_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *DeviceSpecSSHConfig_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Spec_SSHConfig))
}

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

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

func (fps *DeviceSpecSSHConfig_FieldSubPath) WithIValue(value interface{}) DeviceSpecSSHConfig_FieldPathValue {
	return &DeviceSpecSSHConfig_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceSpecSSHConfig_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceSpecSSHConfig_FieldPathArrayOfValues {
	return &DeviceSpecSSHConfig_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceSpecSSHConfig_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceSpecSSHConfig_FieldPathArrayItemValue {
	return &DeviceSpecSSHConfig_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceSpecSSHConfig_FieldPathValue allows storing values for SSHConfig fields according to their type
type DeviceSpecSSHConfig_FieldPathValue interface {
	DeviceSpecSSHConfig_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_SSHConfig)
	CompareWith(*Device_Spec_SSHConfig) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecSSHConfig_FieldPathValue(pathStr, valueStr string) DeviceSpecSSHConfig_FieldPathValue {
	fpv, err := ParseDeviceSpecSSHConfig_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecSSHConfig_FieldTerminalPathValue struct {
	DeviceSpecSSHConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecSSHConfig_FieldPathValue = (*DeviceSpecSSHConfig_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'SSHConfig' as interface{}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsDisableSshServerValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsDisableSshPasswordValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsSshAuthorizedValue() ([]*Device_Spec_SSHConfig_AuthKey, bool) {
	res, ok := fpv.value.([]*Device_Spec_SSHConfig_AuthKey)
	return res, ok
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsIpAllowListValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsIpDenyListValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsRejectPeriodValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) AsDisableSshAuthkeyValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object SSHConfig
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) SetTo(target **Device_Spec_SSHConfig) {
	if *target == nil {
		*target = new(Device_Spec_SSHConfig)
	}
	switch fpv.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		(*target).DisableSshServer = fpv.value.(bool)
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		(*target).DisableSshPassword = fpv.value.(bool)
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		(*target).SshAuthorized = fpv.value.([]*Device_Spec_SSHConfig_AuthKey)
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		(*target).IpAllowList = fpv.value.([]string)
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		(*target).IpDenyList = fpv.value.([]string)
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		(*target).RejectPeriod = fpv.value.(*durationpb.Duration)
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		(*target).DisableSshAuthkey = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecSSHConfig_FieldTerminalPathValue' with the value under path in 'Device_Spec_SSHConfig'.
func (fpv *DeviceSpecSSHConfig_FieldTerminalPathValue) CompareWith(source *Device_Spec_SSHConfig) (int, bool) {
	switch fpv.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		leftValue := fpv.value.(bool)
		rightValue := source.GetDisableSshServer()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		leftValue := fpv.value.(bool)
		rightValue := source.GetDisableSshPassword()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		return 0, false
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		return 0, false
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		return 0, false
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetRejectPeriod()
		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
		}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		leftValue := fpv.value.(bool)
		rightValue := source.GetDisableSshAuthkey()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig: %d", fpv.selector))
	}
}

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

type DeviceSpecSSHConfig_FieldSubPathValue struct {
	DeviceSpecSSHConfig_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceSpecSSHConfig_FieldPathValue = (*DeviceSpecSSHConfig_FieldSubPathValue)(nil)

func (fpvs *DeviceSpecSSHConfig_FieldSubPathValue) AsSshAuthorizedPathValue() (DeviceSpecSSHConfigAuthKey_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecSSHConfigAuthKey_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseDeviceSpecSSHConfig_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecSSHConfig_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecSSHConfig_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue struct {
	DeviceSpecSSHConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecSSHConfig_FieldPathArrayItemValue = (*DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec_SSHConfig as interface{}
func (fpaiv *DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue) AsSshAuthorizedItemValue() (*Device_Spec_SSHConfig_AuthKey, bool) {
	res, ok := fpaiv.value.(*Device_Spec_SSHConfig_AuthKey)
	return res, ok
}
func (fpaiv *DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue) AsIpAllowListItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue) AsIpDenyListItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_SSHConfig) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'SSHConfig'
func (fpaiv *DeviceSpecSSHConfig_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Spec_SSHConfig) bool {
	slice := fpaiv.DeviceSpecSSHConfig_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 DeviceSpecSSHConfig_FieldSubPathArrayItemValue struct {
	DeviceSpecSSHConfig_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// DeviceSpecSSHConfig_FieldPathArrayOfValues allows storing slice of values for SSHConfig fields according to their type
type DeviceSpecSSHConfig_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecSSHConfig_FieldPath
}

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

func MustParseDeviceSpecSSHConfig_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecSSHConfig_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecSSHConfig_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues struct {
	DeviceSpecSSHConfig_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecSSHConfig_FieldPathArrayOfValues = (*DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized:
		for _, v := range fpaov.values.([][]*Device_Spec_SSHConfig_AuthKey) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfig_FieldPathSelectorIpAllowList:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfig_FieldPathSelectorIpDenyList:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsDisableSshServerArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsDisableSshPasswordArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsSshAuthorizedArrayOfValues() ([][]*Device_Spec_SSHConfig_AuthKey, bool) {
	res, ok := fpaov.values.([][]*Device_Spec_SSHConfig_AuthKey)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsIpAllowListArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsIpDenyListArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsRejectPeriodArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfig_FieldTerminalPathArrayOfValues) AsDisableSshAuthkeyArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type DeviceSpecSSHConfig_FieldSubPathArrayOfValues struct {
	DeviceSpecSSHConfig_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceSpecSSHConfig_FieldPathArrayOfValues = (*DeviceSpecSSHConfig_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceSpecSSHConfig_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceSpecSSHConfig_FieldSubPathArrayOfValues) AsSshAuthorizedPathArrayOfValues() (DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceSpecAttestationConfig_FieldPathSelector int32

const (
	DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected DeviceSpecAttestationConfig_FieldPathSelector = 0
	DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain   DeviceSpecAttestationConfig_FieldPathSelector = 1
)

func (s DeviceSpecAttestationConfig_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		return "attestation_expected"
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		return "attestation_domain"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", s))
	}
}

func BuildDeviceSpecAttestationConfig_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecAttestationConfig_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_AttestationConfig")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "attestation_expected", "attestationExpected", "attestation-expected":
			return &DeviceSpecAttestationConfig_FieldTerminalPath{selector: DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected}, nil
		case "attestation_domain", "attestationDomain", "attestation-domain":
			return &DeviceSpecAttestationConfig_FieldTerminalPath{selector: DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_AttestationConfig", fp)
}

func ParseDeviceSpecAttestationConfig_FieldPath(rawField string) (DeviceSpecAttestationConfig_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecAttestationConfig_FieldPath(fp)
}

func MustParseDeviceSpecAttestationConfig_FieldPath(rawField string) DeviceSpecAttestationConfig_FieldPath {
	fp, err := ParseDeviceSpecAttestationConfig_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecAttestationConfig_FieldTerminalPath struct {
	selector DeviceSpecAttestationConfig_FieldPathSelector
}

var _ DeviceSpecAttestationConfig_FieldPath = (*DeviceSpecAttestationConfig_FieldTerminalPath)(nil)

func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) Selector() DeviceSpecAttestationConfig_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		return false
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		return (*iam_attestation_domain.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", fp.selector))
	}
}

func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) ClearValue(item *Device_Spec_AttestationConfig) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
			item.AttestationExpected = false
		case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
			item.AttestationDomain = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_AttestationConfig))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected ||
		fp.selector == DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain
}

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

func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecAttestationConfig_FieldPathValue {
	switch fp.selector {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		return &DeviceSpecAttestationConfig_FieldTerminalPathValue{DeviceSpecAttestationConfig_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		return &DeviceSpecAttestationConfig_FieldTerminalPathValue{DeviceSpecAttestationConfig_FieldTerminalPath: *fp, value: value.(*iam_attestation_domain.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecAttestationConfig_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecAttestationConfig_FieldPathArrayOfValues {
	fpaov := &DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues{DeviceSpecAttestationConfig_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		return &DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues{DeviceSpecAttestationConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		return &DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues{DeviceSpecAttestationConfig_FieldTerminalPath: *fp, values: values.([]*iam_attestation_domain.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceSpecAttestationConfig_FieldPathValue allows storing values for AttestationConfig fields according to their type
type DeviceSpecAttestationConfig_FieldPathValue interface {
	DeviceSpecAttestationConfig_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_AttestationConfig)
	CompareWith(*Device_Spec_AttestationConfig) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecAttestationConfig_FieldPathValue(pathStr, valueStr string) DeviceSpecAttestationConfig_FieldPathValue {
	fpv, err := ParseDeviceSpecAttestationConfig_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecAttestationConfig_FieldTerminalPathValue struct {
	DeviceSpecAttestationConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecAttestationConfig_FieldPathValue = (*DeviceSpecAttestationConfig_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AttestationConfig' as interface{}
func (fpv *DeviceSpecAttestationConfig_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecAttestationConfig_FieldTerminalPathValue) AsAttestationExpectedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecAttestationConfig_FieldTerminalPathValue) AsAttestationDomainValue() (*iam_attestation_domain.Reference, bool) {
	res, ok := fpv.value.(*iam_attestation_domain.Reference)
	return res, ok
}

// SetTo stores value for selected field for object AttestationConfig
func (fpv *DeviceSpecAttestationConfig_FieldTerminalPathValue) SetTo(target **Device_Spec_AttestationConfig) {
	if *target == nil {
		*target = new(Device_Spec_AttestationConfig)
	}
	switch fpv.selector {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		(*target).AttestationExpected = fpv.value.(bool)
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		(*target).AttestationDomain = fpv.value.(*iam_attestation_domain.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecAttestationConfig_FieldTerminalPathValue' with the value under path in 'Device_Spec_AttestationConfig'.
func (fpv *DeviceSpecAttestationConfig_FieldTerminalPathValue) CompareWith(source *Device_Spec_AttestationConfig) (int, bool) {
	switch fpv.selector {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		leftValue := fpv.value.(bool)
		rightValue := source.GetAttestationExpected()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		leftValue := fpv.value.(*iam_attestation_domain.Reference)
		rightValue := source.GetAttestationDomain()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_AttestationConfig: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceSpecAttestationConfig_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecAttestationConfig_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecAttestationConfig_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecAttestationConfig_FieldTerminalPathArrayItemValue struct {
	DeviceSpecAttestationConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecAttestationConfig_FieldPathArrayItemValue = (*DeviceSpecAttestationConfig_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceSpecAttestationConfig_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_AttestationConfig) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecAttestationConfig_FieldPathArrayOfValues allows storing slice of values for AttestationConfig fields according to their type
type DeviceSpecAttestationConfig_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecAttestationConfig_FieldPath
}

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

func MustParseDeviceSpecAttestationConfig_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecAttestationConfig_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecAttestationConfig_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues struct {
	DeviceSpecAttestationConfig_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecAttestationConfig_FieldPathArrayOfValues = (*DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain:
		for _, v := range fpaov.values.([]*iam_attestation_domain.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues) AsAttestationExpectedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecAttestationConfig_FieldTerminalPathArrayOfValues) AsAttestationDomainArrayOfValues() ([]*iam_attestation_domain.Reference, bool) {
	res, ok := fpaov.values.([]*iam_attestation_domain.Reference)
	return res, ok
}

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

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

type DeviceSpecLoggingConfig_FieldPathSelector int32

const (
	DeviceSpecLoggingConfig_FieldPathSelectorPriority               DeviceSpecLoggingConfig_FieldPathSelector = 0
	DeviceSpecLoggingConfig_FieldPathSelectorUnits                  DeviceSpecLoggingConfig_FieldPathSelector = 1
	DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport    DeviceSpecLoggingConfig_FieldPathSelector = 2
	DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig DeviceSpecLoggingConfig_FieldPathSelector = 3
)

func (s DeviceSpecLoggingConfig_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		return "priority"
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		return "units"
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		return "enable_journal_export"
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return "container_logging_config"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", s))
	}
}

func BuildDeviceSpecLoggingConfig_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecLoggingConfig_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_LoggingConfig")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "priority":
			return &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorPriority}, nil
		case "units":
			return &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorUnits}, nil
		case "enable_journal_export", "enableJournalExport", "enable-journal-export":
			return &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport}, nil
		case "container_logging_config", "containerLoggingConfig", "container-logging-config":
			return &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig}, nil
		}
	} else {
		switch fp[0] {
		case "container_logging_config", "containerLoggingConfig", "container-logging-config":
			if subpath, err := BuildDeviceSpecLoggingConfigContainerLoggingConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpecLoggingConfig_FieldSubPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_LoggingConfig", fp)
}

func ParseDeviceSpecLoggingConfig_FieldPath(rawField string) (DeviceSpecLoggingConfig_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecLoggingConfig_FieldPath(fp)
}

func MustParseDeviceSpecLoggingConfig_FieldPath(rawField string) DeviceSpecLoggingConfig_FieldPath {
	fp, err := ParseDeviceSpecLoggingConfig_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecLoggingConfig_FieldTerminalPath struct {
	selector DeviceSpecLoggingConfig_FieldPathSelector
}

var _ DeviceSpecLoggingConfig_FieldPath = (*DeviceSpecLoggingConfig_FieldTerminalPath)(nil)

func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) Selector() DeviceSpecLoggingConfig_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Spec_LoggingConfig
func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) Get(source *Device_Spec_LoggingConfig) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
			values = append(values, source.Priority)
		case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
			for _, value := range source.GetUnits() {
				values = append(values, value)
			}
		case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
			values = append(values, source.EnableJournalExport)
		case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
			if source.ContainerLoggingConfig != nil {
				values = append(values, source.ContainerLoggingConfig)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Spec_LoggingConfig
func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) GetSingle(source *Device_Spec_LoggingConfig) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		return source.GetPriority(), source != nil
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		res := source.GetUnits()
		return res, res != nil
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		return source.GetEnableJournalExport(), source != nil
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		res := source.GetContainerLoggingConfig()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		return int32(0)
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		return ([]string)(nil)
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		return false
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return (*Device_Spec_LoggingConfig_ContainerLoggingConfig)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
	}
}

func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) ClearValue(item *Device_Spec_LoggingConfig) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
			item.Priority = int32(0)
		case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
			item.Units = nil
		case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
			item.EnableJournalExport = false
		case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
			item.ContainerLoggingConfig = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_LoggingConfig))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecLoggingConfig_FieldPathSelectorPriority ||
		fp.selector == DeviceSpecLoggingConfig_FieldPathSelectorUnits ||
		fp.selector == DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport
}

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

func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecLoggingConfig_FieldPathValue {
	switch fp.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		return &DeviceSpecLoggingConfig_FieldTerminalPathValue{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, value: value.(int32)}
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		return &DeviceSpecLoggingConfig_FieldTerminalPathValue{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		return &DeviceSpecLoggingConfig_FieldTerminalPathValue{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return &DeviceSpecLoggingConfig_FieldTerminalPathValue{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, value: value.(*Device_Spec_LoggingConfig_ContainerLoggingConfig)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecLoggingConfig_FieldPathArrayOfValues {
	fpaov := &DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfig_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		return &DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, values: values.([]int32)}
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		return &DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		return &DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return &DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, values: values.([]*Device_Spec_LoggingConfig_ContainerLoggingConfig)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpecLoggingConfig_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpecLoggingConfig_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		return &DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue{DeviceSpecLoggingConfig_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fp.selector))
	}
}

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

type DeviceSpecLoggingConfig_FieldSubPath struct {
	selector DeviceSpecLoggingConfig_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceSpecLoggingConfig_FieldPath = (*DeviceSpecLoggingConfig_FieldSubPath)(nil)

func (fps *DeviceSpecLoggingConfig_FieldSubPath) Selector() DeviceSpecLoggingConfig_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceSpecLoggingConfig_FieldSubPath) AsContainerLoggingConfigSubPath() (DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *DeviceSpecLoggingConfig_FieldSubPath) ClearValue(item *Device_Spec_LoggingConfig) {
	if item != nil {
		switch fps.selector {
		case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
			fps.subPath.ClearValueRaw(item.ContainerLoggingConfig)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fps.selector))
		}
	}
}

func (fps *DeviceSpecLoggingConfig_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Spec_LoggingConfig))
}

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

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

func (fps *DeviceSpecLoggingConfig_FieldSubPath) WithIValue(value interface{}) DeviceSpecLoggingConfig_FieldPathValue {
	return &DeviceSpecLoggingConfig_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceSpecLoggingConfig_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceSpecLoggingConfig_FieldPathArrayOfValues {
	return &DeviceSpecLoggingConfig_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceSpecLoggingConfig_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceSpecLoggingConfig_FieldPathArrayItemValue {
	return &DeviceSpecLoggingConfig_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceSpecLoggingConfig_FieldPathValue allows storing values for LoggingConfig fields according to their type
type DeviceSpecLoggingConfig_FieldPathValue interface {
	DeviceSpecLoggingConfig_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_LoggingConfig)
	CompareWith(*Device_Spec_LoggingConfig) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecLoggingConfig_FieldPathValue(pathStr, valueStr string) DeviceSpecLoggingConfig_FieldPathValue {
	fpv, err := ParseDeviceSpecLoggingConfig_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecLoggingConfig_FieldTerminalPathValue struct {
	DeviceSpecLoggingConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecLoggingConfig_FieldPathValue = (*DeviceSpecLoggingConfig_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LoggingConfig' as interface{}
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) AsPriorityValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) AsUnitsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) AsEnableJournalExportValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) AsContainerLoggingConfigValue() (*Device_Spec_LoggingConfig_ContainerLoggingConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_LoggingConfig_ContainerLoggingConfig)
	return res, ok
}

// SetTo stores value for selected field for object LoggingConfig
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) SetTo(target **Device_Spec_LoggingConfig) {
	if *target == nil {
		*target = new(Device_Spec_LoggingConfig)
	}
	switch fpv.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		(*target).Priority = fpv.value.(int32)
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		(*target).Units = fpv.value.([]string)
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		(*target).EnableJournalExport = fpv.value.(bool)
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		(*target).ContainerLoggingConfig = fpv.value.(*Device_Spec_LoggingConfig_ContainerLoggingConfig)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecLoggingConfig_FieldTerminalPathValue' with the value under path in 'Device_Spec_LoggingConfig'.
func (fpv *DeviceSpecLoggingConfig_FieldTerminalPathValue) CompareWith(source *Device_Spec_LoggingConfig) (int, bool) {
	switch fpv.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPriority()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		return 0, false
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnableJournalExport()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fpv.selector))
	}
}

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

type DeviceSpecLoggingConfig_FieldSubPathValue struct {
	DeviceSpecLoggingConfig_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceSpecLoggingConfig_FieldPathValue = (*DeviceSpecLoggingConfig_FieldSubPathValue)(nil)

func (fpvs *DeviceSpecLoggingConfig_FieldSubPathValue) AsContainerLoggingConfigPathValue() (DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceSpecLoggingConfig_FieldSubPathValue) SetTo(target **Device_Spec_LoggingConfig) {
	if *target == nil {
		*target = new(Device_Spec_LoggingConfig)
	}
	switch fpvs.Selector() {
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		fpvs.subPathValue.(DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue).SetTo(&(*target).ContainerLoggingConfig)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceSpecLoggingConfig_FieldSubPathValue) CompareWith(source *Device_Spec_LoggingConfig) (int, bool) {
	switch fpvs.Selector() {
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return fpvs.subPathValue.(DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue).CompareWith(source.GetContainerLoggingConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceSpecLoggingConfig_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecLoggingConfig_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecLoggingConfig_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue struct {
	DeviceSpecLoggingConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecLoggingConfig_FieldPathArrayItemValue = (*DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec_LoggingConfig as interface{}
func (fpaiv *DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue) AsUnitsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_LoggingConfig) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'LoggingConfig'
func (fpaiv *DeviceSpecLoggingConfig_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Spec_LoggingConfig) bool {
	slice := fpaiv.DeviceSpecLoggingConfig_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 DeviceSpecLoggingConfig_FieldSubPathArrayItemValue struct {
	DeviceSpecLoggingConfig_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'LoggingConfig'
func (fpaivs *DeviceSpecLoggingConfig_FieldSubPathArrayItemValue) ContainsValue(source *Device_Spec_LoggingConfig) bool {
	switch fpaivs.Selector() {
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		return fpaivs.subPathItemValue.(DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayItemValue).ContainsValue(source.GetContainerLoggingConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig: %d", fpaivs.Selector()))
	}
}

// DeviceSpecLoggingConfig_FieldPathArrayOfValues allows storing slice of values for LoggingConfig fields according to their type
type DeviceSpecLoggingConfig_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecLoggingConfig_FieldPath
}

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

func MustParseDeviceSpecLoggingConfig_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecLoggingConfig_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecLoggingConfig_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues struct {
	DeviceSpecLoggingConfig_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecLoggingConfig_FieldPathArrayOfValues = (*DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecLoggingConfig_FieldPathSelectorPriority:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case DeviceSpecLoggingConfig_FieldPathSelectorUnits:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig:
		for _, v := range fpaov.values.([]*Device_Spec_LoggingConfig_ContainerLoggingConfig) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues) AsPriorityArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues) AsUnitsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues) AsEnableJournalExportArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecLoggingConfig_FieldTerminalPathArrayOfValues) AsContainerLoggingConfigArrayOfValues() ([]*Device_Spec_LoggingConfig_ContainerLoggingConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_LoggingConfig_ContainerLoggingConfig)
	return res, ok
}

type DeviceSpecLoggingConfig_FieldSubPathArrayOfValues struct {
	DeviceSpecLoggingConfig_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceSpecLoggingConfig_FieldPathArrayOfValues = (*DeviceSpecLoggingConfig_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceSpecLoggingConfig_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceSpecLoggingConfig_FieldSubPathArrayOfValues) AsContainerLoggingConfigPathArrayOfValues() (DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceSpecProxyConfig_FieldPathSelector int32

const (
	DeviceSpecProxyConfig_FieldPathSelectorHttpProxy       DeviceSpecProxyConfig_FieldPathSelector = 0
	DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy      DeviceSpecProxyConfig_FieldPathSelector = 1
	DeviceSpecProxyConfig_FieldPathSelectorNoProxy         DeviceSpecProxyConfig_FieldPathSelector = 2
	DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces DeviceSpecProxyConfig_FieldPathSelector = 3
)

func (s DeviceSpecProxyConfig_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		return "http_proxy"
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		return "https_proxy"
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		return "no_proxy"
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		return "proxy_interfaces"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", s))
	}
}

func BuildDeviceSpecProxyConfig_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecProxyConfig_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_ProxyConfig")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "http_proxy", "httpProxy", "http-proxy":
			return &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorHttpProxy}, nil
		case "https_proxy", "httpsProxy", "https-proxy":
			return &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy}, nil
		case "no_proxy", "noProxy", "no-proxy":
			return &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorNoProxy}, nil
		case "proxy_interfaces", "proxyInterfaces", "proxy-interfaces":
			return &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_ProxyConfig", fp)
}

func ParseDeviceSpecProxyConfig_FieldPath(rawField string) (DeviceSpecProxyConfig_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecProxyConfig_FieldPath(fp)
}

func MustParseDeviceSpecProxyConfig_FieldPath(rawField string) DeviceSpecProxyConfig_FieldPath {
	fp, err := ParseDeviceSpecProxyConfig_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecProxyConfig_FieldTerminalPath struct {
	selector DeviceSpecProxyConfig_FieldPathSelector
}

var _ DeviceSpecProxyConfig_FieldPath = (*DeviceSpecProxyConfig_FieldTerminalPath)(nil)

func (fp *DeviceSpecProxyConfig_FieldTerminalPath) Selector() DeviceSpecProxyConfig_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Spec_ProxyConfig
func (fp *DeviceSpecProxyConfig_FieldTerminalPath) Get(source *Device_Spec_ProxyConfig) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
			values = append(values, source.HttpProxy)
		case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
			values = append(values, source.HttpsProxy)
		case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
			values = append(values, source.NoProxy)
		case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
			for _, value := range source.GetProxyInterfaces() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Spec_ProxyConfig
func (fp *DeviceSpecProxyConfig_FieldTerminalPath) GetSingle(source *Device_Spec_ProxyConfig) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		return source.GetHttpProxy(), source != nil
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		return source.GetHttpsProxy(), source != nil
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		return source.GetNoProxy(), source != nil
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		res := source.GetProxyInterfaces()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecProxyConfig_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		return ""
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		return ""
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		return ""
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		return ([]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
	}
}

func (fp *DeviceSpecProxyConfig_FieldTerminalPath) ClearValue(item *Device_Spec_ProxyConfig) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
			item.HttpProxy = ""
		case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
			item.HttpsProxy = ""
		case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
			item.NoProxy = ""
		case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
			item.ProxyInterfaces = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecProxyConfig_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_ProxyConfig))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecProxyConfig_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecProxyConfig_FieldPathSelectorHttpProxy ||
		fp.selector == DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy ||
		fp.selector == DeviceSpecProxyConfig_FieldPathSelectorNoProxy ||
		fp.selector == DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces
}

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

func (fp *DeviceSpecProxyConfig_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecProxyConfig_FieldPathValue {
	switch fp.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		return &DeviceSpecProxyConfig_FieldTerminalPathValue{DeviceSpecProxyConfig_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		return &DeviceSpecProxyConfig_FieldTerminalPathValue{DeviceSpecProxyConfig_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		return &DeviceSpecProxyConfig_FieldTerminalPathValue{DeviceSpecProxyConfig_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		return &DeviceSpecProxyConfig_FieldTerminalPathValue{DeviceSpecProxyConfig_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecProxyConfig_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecProxyConfig_FieldPathArrayOfValues {
	fpaov := &DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues{DeviceSpecProxyConfig_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		return &DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues{DeviceSpecProxyConfig_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		return &DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues{DeviceSpecProxyConfig_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		return &DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues{DeviceSpecProxyConfig_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		return &DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues{DeviceSpecProxyConfig_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpecProxyConfig_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpecProxyConfig_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		return &DeviceSpecProxyConfig_FieldTerminalPathArrayItemValue{DeviceSpecProxyConfig_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fp.selector))
	}
}

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

// DeviceSpecProxyConfig_FieldPathValue allows storing values for ProxyConfig fields according to their type
type DeviceSpecProxyConfig_FieldPathValue interface {
	DeviceSpecProxyConfig_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_ProxyConfig)
	CompareWith(*Device_Spec_ProxyConfig) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecProxyConfig_FieldPathValue(pathStr, valueStr string) DeviceSpecProxyConfig_FieldPathValue {
	fpv, err := ParseDeviceSpecProxyConfig_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecProxyConfig_FieldTerminalPathValue struct {
	DeviceSpecProxyConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecProxyConfig_FieldPathValue = (*DeviceSpecProxyConfig_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProxyConfig' as interface{}
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) AsHttpProxyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) AsHttpsProxyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) AsNoProxyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) AsProxyInterfacesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object ProxyConfig
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) SetTo(target **Device_Spec_ProxyConfig) {
	if *target == nil {
		*target = new(Device_Spec_ProxyConfig)
	}
	switch fpv.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		(*target).HttpProxy = fpv.value.(string)
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		(*target).HttpsProxy = fpv.value.(string)
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		(*target).NoProxy = fpv.value.(string)
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		(*target).ProxyInterfaces = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecProxyConfig_FieldTerminalPathValue' with the value under path in 'Device_Spec_ProxyConfig'.
func (fpv *DeviceSpecProxyConfig_FieldTerminalPathValue) CompareWith(source *Device_Spec_ProxyConfig) (int, bool) {
	switch fpv.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		leftValue := fpv.value.(string)
		rightValue := source.GetHttpProxy()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		leftValue := fpv.value.(string)
		rightValue := source.GetHttpsProxy()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		leftValue := fpv.value.(string)
		rightValue := source.GetNoProxy()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_ProxyConfig: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceSpecProxyConfig_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecProxyConfig_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecProxyConfig_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecProxyConfig_FieldTerminalPathArrayItemValue struct {
	DeviceSpecProxyConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecProxyConfig_FieldPathArrayItemValue = (*DeviceSpecProxyConfig_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec_ProxyConfig as interface{}
func (fpaiv *DeviceSpecProxyConfig_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpecProxyConfig_FieldTerminalPathArrayItemValue) AsProxyInterfacesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceSpecProxyConfig_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_ProxyConfig) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecProxyConfig_FieldPathArrayOfValues allows storing slice of values for ProxyConfig fields according to their type
type DeviceSpecProxyConfig_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecProxyConfig_FieldPath
}

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

func MustParseDeviceSpecProxyConfig_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecProxyConfig_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecProxyConfig_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues struct {
	DeviceSpecProxyConfig_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecProxyConfig_FieldPathArrayOfValues = (*DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecProxyConfig_FieldPathSelectorHttpProxy:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecProxyConfig_FieldPathSelectorNoProxy:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues) AsHttpProxyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues) AsHttpsProxyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues) AsNoProxyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecProxyConfig_FieldTerminalPathArrayOfValues) AsProxyInterfacesArrayOfValues() ([][]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 DeviceSpecLocation_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceSpecLocation_FieldPathSelector
	Get(source *Device_Spec_Location) []interface{}
	GetSingle(source *Device_Spec_Location) (interface{}, bool)
	ClearValue(item *Device_Spec_Location)

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

type DeviceSpecLocation_FieldPathSelector int32

const (
	DeviceSpecLocation_FieldPathSelectorAddress   DeviceSpecLocation_FieldPathSelector = 0
	DeviceSpecLocation_FieldPathSelectorPlacement DeviceSpecLocation_FieldPathSelector = 1
)

func (s DeviceSpecLocation_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecLocation_FieldPathSelectorAddress:
		return "address"
	case DeviceSpecLocation_FieldPathSelectorPlacement:
		return "placement"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_Location: %d", s))
	}
}

func BuildDeviceSpecLocation_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecLocation_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_Location")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "address":
			return &DeviceSpecLocation_FieldTerminalPath{selector: DeviceSpecLocation_FieldPathSelectorAddress}, nil
		case "placement":
			return &DeviceSpecLocation_FieldTerminalPath{selector: DeviceSpecLocation_FieldPathSelectorPlacement}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_Location", fp)
}

func ParseDeviceSpecLocation_FieldPath(rawField string) (DeviceSpecLocation_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecLocation_FieldPath(fp)
}

func MustParseDeviceSpecLocation_FieldPath(rawField string) DeviceSpecLocation_FieldPath {
	fp, err := ParseDeviceSpecLocation_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecLocation_FieldTerminalPath struct {
	selector DeviceSpecLocation_FieldPathSelector
}

var _ DeviceSpecLocation_FieldPath = (*DeviceSpecLocation_FieldTerminalPath)(nil)

func (fp *DeviceSpecLocation_FieldTerminalPath) Selector() DeviceSpecLocation_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source Device_Spec_Location
func (fp *DeviceSpecLocation_FieldTerminalPath) GetSingle(source *Device_Spec_Location) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpecLocation_FieldPathSelectorAddress:
		return source.GetAddress(), source != nil
	case DeviceSpecLocation_FieldPathSelectorPlacement:
		return source.GetPlacement(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_Location: %d", fp.selector))
	}
}

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

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

func (fp *DeviceSpecLocation_FieldTerminalPath) ClearValue(item *Device_Spec_Location) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecLocation_FieldPathSelectorAddress:
			item.Address = ""
		case DeviceSpecLocation_FieldPathSelectorPlacement:
			item.Placement = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_Location: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecLocation_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_Location))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecLocation_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecLocation_FieldPathSelectorAddress ||
		fp.selector == DeviceSpecLocation_FieldPathSelectorPlacement
}

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

func (fp *DeviceSpecLocation_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecLocation_FieldPathValue {
	switch fp.selector {
	case DeviceSpecLocation_FieldPathSelectorAddress:
		return &DeviceSpecLocation_FieldTerminalPathValue{DeviceSpecLocation_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecLocation_FieldPathSelectorPlacement:
		return &DeviceSpecLocation_FieldTerminalPathValue{DeviceSpecLocation_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_Location: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecLocation_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecLocation_FieldPathArrayOfValues {
	fpaov := &DeviceSpecLocation_FieldTerminalPathArrayOfValues{DeviceSpecLocation_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecLocation_FieldPathSelectorAddress:
		return &DeviceSpecLocation_FieldTerminalPathArrayOfValues{DeviceSpecLocation_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecLocation_FieldPathSelectorPlacement:
		return &DeviceSpecLocation_FieldTerminalPathArrayOfValues{DeviceSpecLocation_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_Location: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceSpecLocation_FieldPathValue allows storing values for Location fields according to their type
type DeviceSpecLocation_FieldPathValue interface {
	DeviceSpecLocation_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_Location)
	CompareWith(*Device_Spec_Location) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecLocation_FieldPathValue(pathStr, valueStr string) DeviceSpecLocation_FieldPathValue {
	fpv, err := ParseDeviceSpecLocation_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecLocation_FieldTerminalPathValue struct {
	DeviceSpecLocation_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecLocation_FieldPathValue = (*DeviceSpecLocation_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Location
func (fpv *DeviceSpecLocation_FieldTerminalPathValue) SetTo(target **Device_Spec_Location) {
	if *target == nil {
		*target = new(Device_Spec_Location)
	}
	switch fpv.selector {
	case DeviceSpecLocation_FieldPathSelectorAddress:
		(*target).Address = fpv.value.(string)
	case DeviceSpecLocation_FieldPathSelectorPlacement:
		(*target).Placement = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_Location: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseDeviceSpecLocation_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecLocation_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecLocation_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecLocation_FieldTerminalPathArrayItemValue struct {
	DeviceSpecLocation_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecLocation_FieldPathArrayItemValue = (*DeviceSpecLocation_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceSpecLocation_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_Location) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecLocation_FieldPathArrayOfValues allows storing slice of values for Location fields according to their type
type DeviceSpecLocation_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecLocation_FieldPath
}

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

func MustParseDeviceSpecLocation_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecLocation_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecLocation_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecLocation_FieldTerminalPathArrayOfValues struct {
	DeviceSpecLocation_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecLocation_FieldPathArrayOfValues = (*DeviceSpecLocation_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecLocation_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecLocation_FieldPathSelectorAddress:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecLocation_FieldPathSelectorPlacement:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecLocation_FieldTerminalPathArrayOfValues) AsAddressArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecLocation_FieldTerminalPathArrayOfValues) AsPlacementArrayOfValues() ([]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 DeviceSpecUSBGuard_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceSpecUSBGuard_FieldPathSelector
	Get(source *Device_Spec_USBGuard) []interface{}
	GetSingle(source *Device_Spec_USBGuard) (interface{}, bool)
	ClearValue(item *Device_Spec_USBGuard)

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

type DeviceSpecUSBGuard_FieldPathSelector int32

const (
	DeviceSpecUSBGuard_FieldPathSelectorEnable    DeviceSpecUSBGuard_FieldPathSelector = 0
	DeviceSpecUSBGuard_FieldPathSelectorWhiteList DeviceSpecUSBGuard_FieldPathSelector = 1
)

func (s DeviceSpecUSBGuard_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		return "enable"
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		return "white_list"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", s))
	}
}

func BuildDeviceSpecUSBGuard_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecUSBGuard_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_USBGuard")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "enable":
			return &DeviceSpecUSBGuard_FieldTerminalPath{selector: DeviceSpecUSBGuard_FieldPathSelectorEnable}, nil
		case "white_list", "whiteList", "white-list":
			return &DeviceSpecUSBGuard_FieldTerminalPath{selector: DeviceSpecUSBGuard_FieldPathSelectorWhiteList}, nil
		}
	} else {
		switch fp[0] {
		case "white_list", "whiteList", "white-list":
			if subpath, err := BuildDeviceSpecUSBGuardWhiteList_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpecUSBGuard_FieldSubPath{selector: DeviceSpecUSBGuard_FieldPathSelectorWhiteList, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_USBGuard", fp)
}

func ParseDeviceSpecUSBGuard_FieldPath(rawField string) (DeviceSpecUSBGuard_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecUSBGuard_FieldPath(fp)
}

func MustParseDeviceSpecUSBGuard_FieldPath(rawField string) DeviceSpecUSBGuard_FieldPath {
	fp, err := ParseDeviceSpecUSBGuard_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecUSBGuard_FieldTerminalPath struct {
	selector DeviceSpecUSBGuard_FieldPathSelector
}

var _ DeviceSpecUSBGuard_FieldPath = (*DeviceSpecUSBGuard_FieldTerminalPath)(nil)

func (fp *DeviceSpecUSBGuard_FieldTerminalPath) Selector() DeviceSpecUSBGuard_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecUSBGuard_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		return false
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		return ([]*Device_Spec_USBGuard_WhiteList)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fp.selector))
	}
}

func (fp *DeviceSpecUSBGuard_FieldTerminalPath) ClearValue(item *Device_Spec_USBGuard) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecUSBGuard_FieldPathSelectorEnable:
			item.Enable = false
		case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
			item.WhiteList = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecUSBGuard_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_USBGuard))
}

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

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

func (fp *DeviceSpecUSBGuard_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecUSBGuard_FieldPathValue {
	switch fp.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		return &DeviceSpecUSBGuard_FieldTerminalPathValue{DeviceSpecUSBGuard_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		return &DeviceSpecUSBGuard_FieldTerminalPathValue{DeviceSpecUSBGuard_FieldTerminalPath: *fp, value: value.([]*Device_Spec_USBGuard_WhiteList)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecUSBGuard_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecUSBGuard_FieldPathArrayOfValues {
	fpaov := &DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuard_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		return &DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuard_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		return &DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuard_FieldTerminalPath: *fp, values: values.([][]*Device_Spec_USBGuard_WhiteList)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpecUSBGuard_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpecUSBGuard_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		return &DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue{DeviceSpecUSBGuard_FieldTerminalPath: *fp, value: value.(*Device_Spec_USBGuard_WhiteList)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fp.selector))
	}
}

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

type DeviceSpecUSBGuard_FieldSubPath struct {
	selector DeviceSpecUSBGuard_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceSpecUSBGuard_FieldPath = (*DeviceSpecUSBGuard_FieldSubPath)(nil)

func (fps *DeviceSpecUSBGuard_FieldSubPath) Selector() DeviceSpecUSBGuard_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceSpecUSBGuard_FieldSubPath) AsWhiteListSubPath() (DeviceSpecUSBGuardWhiteList_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecUSBGuardWhiteList_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *DeviceSpecUSBGuard_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Spec_USBGuard))
}

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

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

func (fps *DeviceSpecUSBGuard_FieldSubPath) WithIValue(value interface{}) DeviceSpecUSBGuard_FieldPathValue {
	return &DeviceSpecUSBGuard_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceSpecUSBGuard_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceSpecUSBGuard_FieldPathArrayOfValues {
	return &DeviceSpecUSBGuard_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceSpecUSBGuard_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceSpecUSBGuard_FieldPathArrayItemValue {
	return &DeviceSpecUSBGuard_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceSpecUSBGuard_FieldPathValue allows storing values for USBGuard fields according to their type
type DeviceSpecUSBGuard_FieldPathValue interface {
	DeviceSpecUSBGuard_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_USBGuard)
	CompareWith(*Device_Spec_USBGuard) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecUSBGuard_FieldPathValue(pathStr, valueStr string) DeviceSpecUSBGuard_FieldPathValue {
	fpv, err := ParseDeviceSpecUSBGuard_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecUSBGuard_FieldTerminalPathValue struct {
	DeviceSpecUSBGuard_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuard_FieldPathValue = (*DeviceSpecUSBGuard_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'USBGuard' as interface{}
func (fpv *DeviceSpecUSBGuard_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecUSBGuard_FieldTerminalPathValue) AsEnableValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecUSBGuard_FieldTerminalPathValue) AsWhiteListValue() ([]*Device_Spec_USBGuard_WhiteList, bool) {
	res, ok := fpv.value.([]*Device_Spec_USBGuard_WhiteList)
	return res, ok
}

// SetTo stores value for selected field for object USBGuard
func (fpv *DeviceSpecUSBGuard_FieldTerminalPathValue) SetTo(target **Device_Spec_USBGuard) {
	if *target == nil {
		*target = new(Device_Spec_USBGuard)
	}
	switch fpv.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		(*target).Enable = fpv.value.(bool)
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		(*target).WhiteList = fpv.value.([]*Device_Spec_USBGuard_WhiteList)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecUSBGuard_FieldTerminalPathValue' with the value under path in 'Device_Spec_USBGuard'.
func (fpv *DeviceSpecUSBGuard_FieldTerminalPathValue) CompareWith(source *Device_Spec_USBGuard) (int, bool) {
	switch fpv.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnable()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard: %d", fpv.selector))
	}
}

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

type DeviceSpecUSBGuard_FieldSubPathValue struct {
	DeviceSpecUSBGuard_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceSpecUSBGuard_FieldPathValue = (*DeviceSpecUSBGuard_FieldSubPathValue)(nil)

func (fpvs *DeviceSpecUSBGuard_FieldSubPathValue) AsWhiteListPathValue() (DeviceSpecUSBGuardWhiteList_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecUSBGuardWhiteList_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseDeviceSpecUSBGuard_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecUSBGuard_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecUSBGuard_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue struct {
	DeviceSpecUSBGuard_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuard_FieldPathArrayItemValue = (*DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec_USBGuard as interface{}
func (fpaiv *DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue) AsWhiteListItemValue() (*Device_Spec_USBGuard_WhiteList, bool) {
	res, ok := fpaiv.value.(*Device_Spec_USBGuard_WhiteList)
	return res, ok
}

func (fpaiv *DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_USBGuard) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'USBGuard'
func (fpaiv *DeviceSpecUSBGuard_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Spec_USBGuard) bool {
	slice := fpaiv.DeviceSpecUSBGuard_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 DeviceSpecUSBGuard_FieldSubPathArrayItemValue struct {
	DeviceSpecUSBGuard_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// DeviceSpecUSBGuard_FieldPathArrayOfValues allows storing slice of values for USBGuard fields according to their type
type DeviceSpecUSBGuard_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecUSBGuard_FieldPath
}

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

func MustParseDeviceSpecUSBGuard_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecUSBGuard_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecUSBGuard_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues struct {
	DeviceSpecUSBGuard_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecUSBGuard_FieldPathArrayOfValues = (*DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecUSBGuard_FieldPathSelectorEnable:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuard_FieldPathSelectorWhiteList:
		for _, v := range fpaov.values.([][]*Device_Spec_USBGuard_WhiteList) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues) AsEnableArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuard_FieldTerminalPathArrayOfValues) AsWhiteListArrayOfValues() ([][]*Device_Spec_USBGuard_WhiteList, bool) {
	res, ok := fpaov.values.([][]*Device_Spec_USBGuard_WhiteList)
	return res, ok
}

type DeviceSpecUSBGuard_FieldSubPathArrayOfValues struct {
	DeviceSpecUSBGuard_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceSpecUSBGuard_FieldPathArrayOfValues = (*DeviceSpecUSBGuard_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceSpecUSBGuard_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceSpecUSBGuard_FieldSubPathArrayOfValues) AsWhiteListPathArrayOfValues() (DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceSpecSSHConfigAuthKey_FieldPathSelector int32

const (
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey           DeviceSpecSSHConfigAuthKey_FieldPathSelector = 0
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority     DeviceSpecSSHConfigAuthKey_FieldPathSelector = 1
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand           DeviceSpecSSHConfigAuthKey_FieldPathSelector = 2
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment       DeviceSpecSSHConfigAuthKey_FieldPathSelector = 3
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom              DeviceSpecSSHConfigAuthKey_FieldPathSelector = 4
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding DeviceSpecSSHConfigAuthKey_FieldPathSelector = 5
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding  DeviceSpecSSHConfigAuthKey_FieldPathSelector = 6
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty             DeviceSpecSSHConfigAuthKey_FieldPathSelector = 7
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc          DeviceSpecSSHConfigAuthKey_FieldPathSelector = 8
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding   DeviceSpecSSHConfigAuthKey_FieldPathSelector = 9
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen        DeviceSpecSSHConfigAuthKey_FieldPathSelector = 10
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals        DeviceSpecSSHConfigAuthKey_FieldPathSelector = 11
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel            DeviceSpecSSHConfigAuthKey_FieldPathSelector = 12
	DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict          DeviceSpecSSHConfigAuthKey_FieldPathSelector = 13
)

func (s DeviceSpecSSHConfigAuthKey_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		return "ssha_key"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		return "cert_authority"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		return "command"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		return "environment"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		return "from"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		return "no_agent_forwarding"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		return "no_port_forwarding"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		return "no_pty"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		return "no_user_rc"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		return "no_x11_forwarding"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		return "permitopen"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		return "principals"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		return "tunnel"
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		return "restrict"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", s))
	}
}

func BuildDeviceSpecSSHConfigAuthKey_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecSSHConfigAuthKey_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_SSHConfig_AuthKey")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "ssha_key", "sshaKey", "ssha-key":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey}, nil
		case "cert_authority", "certAuthority", "cert-authority":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority}, nil
		case "command":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand}, nil
		case "environment":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment}, nil
		case "from":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom}, nil
		case "no_agent_forwarding", "noAgentForwarding", "no-agent-forwarding":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding}, nil
		case "no_port_forwarding", "noPortForwarding", "no-port-forwarding":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding}, nil
		case "no_pty", "noPty", "no-pty":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty}, nil
		case "no_user_rc", "noUserRc", "no-user-rc":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc}, nil
		case "no_x11_forwarding", "noX11Forwarding", "no-x11-forwarding":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding}, nil
		case "permitopen":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen}, nil
		case "principals":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals}, nil
		case "tunnel":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel}, nil
		case "restrict":
			return &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_SSHConfig_AuthKey", fp)
}

func ParseDeviceSpecSSHConfigAuthKey_FieldPath(rawField string) (DeviceSpecSSHConfigAuthKey_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecSSHConfigAuthKey_FieldPath(fp)
}

func MustParseDeviceSpecSSHConfigAuthKey_FieldPath(rawField string) DeviceSpecSSHConfigAuthKey_FieldPath {
	fp, err := ParseDeviceSpecSSHConfigAuthKey_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecSSHConfigAuthKey_FieldTerminalPath struct {
	selector DeviceSpecSSHConfigAuthKey_FieldPathSelector
}

var _ DeviceSpecSSHConfigAuthKey_FieldPath = (*DeviceSpecSSHConfigAuthKey_FieldTerminalPath)(nil)

func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) Selector() DeviceSpecSSHConfigAuthKey_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Spec_SSHConfig_AuthKey
func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) Get(source *Device_Spec_SSHConfig_AuthKey) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
			values = append(values, source.SshaKey)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
			values = append(values, source.CertAuthority)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
			values = append(values, source.Command)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
			values = append(values, source.Environment)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
			values = append(values, source.From)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
			values = append(values, source.NoAgentForwarding)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
			values = append(values, source.NoPortForwarding)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
			values = append(values, source.NoPty)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
			values = append(values, source.NoUserRc)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
			values = append(values, source.NoX11Forwarding)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
			values = append(values, source.Permitopen)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
			values = append(values, source.Principals)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
			values = append(values, source.Tunnel)
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
			values = append(values, source.Restrict)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Spec_SSHConfig_AuthKey
func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) GetSingle(source *Device_Spec_SSHConfig_AuthKey) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		return source.GetSshaKey(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		return source.GetCertAuthority(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		return source.GetCommand(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		return source.GetEnvironment(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		return source.GetFrom(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		return source.GetNoAgentForwarding(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		return source.GetNoPortForwarding(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		return source.GetNoPty(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		return source.GetNoUserRc(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		return source.GetNoX11Forwarding(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		return source.GetPermitopen(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		return source.GetPrincipals(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		return source.GetTunnel(), source != nil
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		return source.GetRestrict(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		return false
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		return false
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		return false
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		return false
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		return false
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		return false
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		return ""
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fp.selector))
	}
}

func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) ClearValue(item *Device_Spec_SSHConfig_AuthKey) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
			item.SshaKey = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
			item.CertAuthority = false
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
			item.Command = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
			item.Environment = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
			item.From = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
			item.NoAgentForwarding = false
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
			item.NoPortForwarding = false
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
			item.NoPty = false
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
			item.NoUserRc = false
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
			item.NoX11Forwarding = false
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
			item.Permitopen = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
			item.Principals = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
			item.Tunnel = ""
		case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
			item.Restrict = false
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_SSHConfig_AuthKey))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel ||
		fp.selector == DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict
}

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

func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecSSHConfigAuthKey_FieldPathValue {
	switch fp.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecSSHConfigAuthKey_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues {
	fpaov := &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		return &DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues{DeviceSpecSSHConfigAuthKey_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceSpecSSHConfigAuthKey_FieldPathValue allows storing values for AuthKey fields according to their type
type DeviceSpecSSHConfigAuthKey_FieldPathValue interface {
	DeviceSpecSSHConfigAuthKey_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_SSHConfig_AuthKey)
	CompareWith(*Device_Spec_SSHConfig_AuthKey) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecSSHConfigAuthKey_FieldPathValue(pathStr, valueStr string) DeviceSpecSSHConfigAuthKey_FieldPathValue {
	fpv, err := ParseDeviceSpecSSHConfigAuthKey_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue struct {
	DeviceSpecSSHConfigAuthKey_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecSSHConfigAuthKey_FieldPathValue = (*DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AuthKey' as interface{}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsSshaKeyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsCertAuthorityValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsCommandValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsEnvironmentValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsFromValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsNoAgentForwardingValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsNoPortForwardingValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsNoPtyValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsNoUserRcValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsNoX11ForwardingValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsPermitopenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsPrincipalsValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsTunnelValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) AsRestrictValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object AuthKey
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) SetTo(target **Device_Spec_SSHConfig_AuthKey) {
	if *target == nil {
		*target = new(Device_Spec_SSHConfig_AuthKey)
	}
	switch fpv.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		(*target).SshaKey = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		(*target).CertAuthority = fpv.value.(bool)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		(*target).Command = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		(*target).Environment = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		(*target).From = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		(*target).NoAgentForwarding = fpv.value.(bool)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		(*target).NoPortForwarding = fpv.value.(bool)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		(*target).NoPty = fpv.value.(bool)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		(*target).NoUserRc = fpv.value.(bool)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		(*target).NoX11Forwarding = fpv.value.(bool)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		(*target).Permitopen = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		(*target).Principals = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		(*target).Tunnel = fpv.value.(string)
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		(*target).Restrict = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue' with the value under path in 'Device_Spec_SSHConfig_AuthKey'.
func (fpv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathValue) CompareWith(source *Device_Spec_SSHConfig_AuthKey) (int, bool) {
	switch fpv.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		leftValue := fpv.value.(string)
		rightValue := source.GetSshaKey()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		leftValue := fpv.value.(bool)
		rightValue := source.GetCertAuthority()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		leftValue := fpv.value.(string)
		rightValue := source.GetCommand()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		leftValue := fpv.value.(string)
		rightValue := source.GetEnvironment()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		leftValue := fpv.value.(string)
		rightValue := source.GetFrom()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNoAgentForwarding()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNoPortForwarding()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNoPty()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNoUserRc()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNoX11Forwarding()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		leftValue := fpv.value.(string)
		rightValue := source.GetPermitopen()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		leftValue := fpv.value.(string)
		rightValue := source.GetPrincipals()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		leftValue := fpv.value.(string)
		rightValue := source.GetTunnel()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		leftValue := fpv.value.(bool)
		rightValue := source.GetRestrict()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_SSHConfig_AuthKey: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceSpecSSHConfigAuthKey_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecSSHConfigAuthKey_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecSSHConfigAuthKey_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayItemValue struct {
	DeviceSpecSSHConfigAuthKey_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecSSHConfigAuthKey_FieldPathArrayItemValue = (*DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_SSHConfig_AuthKey) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues allows storing slice of values for AuthKey fields according to their type
type DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecSSHConfigAuthKey_FieldPath
}

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

func MustParseDeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues struct {
	DeviceSpecSSHConfigAuthKey_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecSSHConfigAuthKey_FieldPathArrayOfValues = (*DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsSshaKeyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsCertAuthorityArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsCommandArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsEnvironmentArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsFromArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsNoAgentForwardingArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsNoPortForwardingArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsNoPtyArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsNoUserRcArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsNoX11ForwardingArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsPermitopenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsPrincipalsArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsTunnelArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecSSHConfigAuthKey_FieldTerminalPathArrayOfValues) AsRestrictArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

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

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

type DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelector int32

const (
	DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelector = 0
)

func (s DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport:
		return "enable_container_log_export"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig_ContainerLoggingConfig: %d", s))
	}
}

func BuildDeviceSpecLoggingConfigContainerLoggingConfig_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_LoggingConfig_ContainerLoggingConfig")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "enable_container_log_export", "enableContainerLogExport", "enable-container-log-export":
			return &DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_LoggingConfig_ContainerLoggingConfig", fp)
}

func ParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPath(rawField string) (DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecLoggingConfigContainerLoggingConfig_FieldPath(fp)
}

func MustParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPath(rawField string) DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath {
	fp, err := ParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath struct {
	selector DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelector
}

var _ DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath = (*DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath)(nil)

func (fp *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath) Selector() DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath) ClearValue(item *Device_Spec_LoggingConfig_ContainerLoggingConfig) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport:
			item.EnableContainerLogExport = false
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig_ContainerLoggingConfig: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_LoggingConfig_ContainerLoggingConfig))
}

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

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

func (fp *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue {
	switch fp.selector {
	case DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport:
		return &DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathValue{DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig_ContainerLoggingConfig: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues {
	fpaov := &DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport:
		return &DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayOfValues{DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig_ContainerLoggingConfig: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue allows storing values for ContainerLoggingConfig fields according to their type
type DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue interface {
	DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_LoggingConfig_ContainerLoggingConfig)
	CompareWith(*Device_Spec_LoggingConfig_ContainerLoggingConfig) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue(pathStr, valueStr string) DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue {
	fpv, err := ParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathValue struct {
	DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathValue = (*DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object ContainerLoggingConfig
func (fpv *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathValue) SetTo(target **Device_Spec_LoggingConfig_ContainerLoggingConfig) {
	if *target == nil {
		*target = new(Device_Spec_LoggingConfig_ContainerLoggingConfig)
	}
	switch fpv.selector {
	case DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport:
		(*target).EnableContainerLogExport = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig_ContainerLoggingConfig: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathValue' with the value under path in 'Device_Spec_LoggingConfig_ContainerLoggingConfig'.
func (fpv *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathValue) CompareWith(source *Device_Spec_LoggingConfig_ContainerLoggingConfig) (int, bool) {
	switch fpv.selector {
	case DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnableContainerLogExport()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_LoggingConfig_ContainerLoggingConfig: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayItemValue struct {
	DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayItemValue = (*DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_LoggingConfig_ContainerLoggingConfig) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues allows storing slice of values for ContainerLoggingConfig fields according to their type
type DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecLoggingConfigContainerLoggingConfig_FieldPath
}

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

func MustParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayOfValues struct {
	DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathArrayOfValues = (*DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type DeviceSpecUSBGuardPort_FieldPathSelector int32

const (
	DeviceSpecUSBGuardPort_FieldPathSelectorEquals DeviceSpecUSBGuardPort_FieldPathSelector = 0
	DeviceSpecUSBGuardPort_FieldPathSelectorOneOf  DeviceSpecUSBGuardPort_FieldPathSelector = 1
)

func (s DeviceSpecUSBGuardPort_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
		return "equals"
	case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
		return "one_of"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Port: %d", s))
	}
}

func BuildDeviceSpecUSBGuardPort_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecUSBGuardPort_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_USBGuard_Port")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "equals":
			return &DeviceSpecUSBGuardPort_FieldTerminalPath{selector: DeviceSpecUSBGuardPort_FieldPathSelectorEquals}, nil
		case "one_of", "oneOf", "one-of":
			return &DeviceSpecUSBGuardPort_FieldTerminalPath{selector: DeviceSpecUSBGuardPort_FieldPathSelectorOneOf}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_USBGuard_Port", fp)
}

func ParseDeviceSpecUSBGuardPort_FieldPath(rawField string) (DeviceSpecUSBGuardPort_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecUSBGuardPort_FieldPath(fp)
}

func MustParseDeviceSpecUSBGuardPort_FieldPath(rawField string) DeviceSpecUSBGuardPort_FieldPath {
	fp, err := ParseDeviceSpecUSBGuardPort_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecUSBGuardPort_FieldTerminalPath struct {
	selector DeviceSpecUSBGuardPort_FieldPathSelector
}

var _ DeviceSpecUSBGuardPort_FieldPath = (*DeviceSpecUSBGuardPort_FieldTerminalPath)(nil)

func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) Selector() DeviceSpecUSBGuardPort_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) ClearValue(item *Device_Spec_USBGuard_Port) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
			item.Equals = nil
		case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
			item.OneOf = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Port: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_USBGuard_Port))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecUSBGuardPort_FieldPathSelectorEquals ||
		fp.selector == DeviceSpecUSBGuardPort_FieldPathSelectorOneOf
}

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

func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecUSBGuardPort_FieldPathValue {
	switch fp.selector {
	case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
		return &DeviceSpecUSBGuardPort_FieldTerminalPathValue{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
		return &DeviceSpecUSBGuardPort_FieldTerminalPathValue{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Port: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecUSBGuardPort_FieldPathArrayOfValues {
	fpaov := &DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
		return &DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
		return &DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Port: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpecUSBGuardPort_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpecUSBGuardPort_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
		return &DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
		return &DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue{DeviceSpecUSBGuardPort_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Port: %d", fp.selector))
	}
}

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

// DeviceSpecUSBGuardPort_FieldPathValue allows storing values for Port fields according to their type
type DeviceSpecUSBGuardPort_FieldPathValue interface {
	DeviceSpecUSBGuardPort_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_USBGuard_Port)
	CompareWith(*Device_Spec_USBGuard_Port) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecUSBGuardPort_FieldPathValue(pathStr, valueStr string) DeviceSpecUSBGuardPort_FieldPathValue {
	fpv, err := ParseDeviceSpecUSBGuardPort_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecUSBGuardPort_FieldTerminalPathValue struct {
	DeviceSpecUSBGuardPort_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuardPort_FieldPathValue = (*DeviceSpecUSBGuardPort_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Port' as interface{}
func (fpv *DeviceSpecUSBGuardPort_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecUSBGuardPort_FieldTerminalPathValue) AsEqualsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceSpecUSBGuardPort_FieldTerminalPathValue) AsOneOfValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object Port
func (fpv *DeviceSpecUSBGuardPort_FieldTerminalPathValue) SetTo(target **Device_Spec_USBGuard_Port) {
	if *target == nil {
		*target = new(Device_Spec_USBGuard_Port)
	}
	switch fpv.selector {
	case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
		(*target).Equals = fpv.value.([]string)
	case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
		(*target).OneOf = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Port: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseDeviceSpecUSBGuardPort_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecUSBGuardPort_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecUSBGuardPort_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue struct {
	DeviceSpecUSBGuardPort_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuardPort_FieldPathArrayItemValue = (*DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec_USBGuard_Port as interface{}
func (fpaiv *DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue) AsEqualsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue) AsOneOfItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceSpecUSBGuardPort_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_USBGuard_Port) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecUSBGuardPort_FieldPathArrayOfValues allows storing slice of values for Port fields according to their type
type DeviceSpecUSBGuardPort_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecUSBGuardPort_FieldPath
}

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

func MustParseDeviceSpecUSBGuardPort_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecUSBGuardPort_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecUSBGuardPort_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues struct {
	DeviceSpecUSBGuardPort_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecUSBGuardPort_FieldPathArrayOfValues = (*DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecUSBGuardPort_FieldPathSelectorEquals:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuardPort_FieldPathSelectorOneOf:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues) AsEqualsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuardPort_FieldTerminalPathArrayOfValues) AsOneOfArrayOfValues() ([][]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 DeviceSpecUSBGuardInterface_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceSpecUSBGuardInterface_FieldPathSelector
	Get(source *Device_Spec_USBGuard_Interface) []interface{}
	GetSingle(source *Device_Spec_USBGuard_Interface) (interface{}, bool)
	ClearValue(item *Device_Spec_USBGuard_Interface)

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

type DeviceSpecUSBGuardInterface_FieldPathSelector int32

const (
	DeviceSpecUSBGuardInterface_FieldPathSelectorEquals DeviceSpecUSBGuardInterface_FieldPathSelector = 0
	DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf  DeviceSpecUSBGuardInterface_FieldPathSelector = 1
)

func (s DeviceSpecUSBGuardInterface_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
		return "equals"
	case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
		return "one_of"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Interface: %d", s))
	}
}

func BuildDeviceSpecUSBGuardInterface_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecUSBGuardInterface_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_USBGuard_Interface")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "equals":
			return &DeviceSpecUSBGuardInterface_FieldTerminalPath{selector: DeviceSpecUSBGuardInterface_FieldPathSelectorEquals}, nil
		case "one_of", "oneOf", "one-of":
			return &DeviceSpecUSBGuardInterface_FieldTerminalPath{selector: DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_USBGuard_Interface", fp)
}

func ParseDeviceSpecUSBGuardInterface_FieldPath(rawField string) (DeviceSpecUSBGuardInterface_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecUSBGuardInterface_FieldPath(fp)
}

func MustParseDeviceSpecUSBGuardInterface_FieldPath(rawField string) DeviceSpecUSBGuardInterface_FieldPath {
	fp, err := ParseDeviceSpecUSBGuardInterface_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecUSBGuardInterface_FieldTerminalPath struct {
	selector DeviceSpecUSBGuardInterface_FieldPathSelector
}

var _ DeviceSpecUSBGuardInterface_FieldPath = (*DeviceSpecUSBGuardInterface_FieldTerminalPath)(nil)

func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) Selector() DeviceSpecUSBGuardInterface_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) ClearValue(item *Device_Spec_USBGuard_Interface) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
			item.Equals = nil
		case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
			item.OneOf = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Interface: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_USBGuard_Interface))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecUSBGuardInterface_FieldPathSelectorEquals ||
		fp.selector == DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf
}

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

func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecUSBGuardInterface_FieldPathValue {
	switch fp.selector {
	case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
		return &DeviceSpecUSBGuardInterface_FieldTerminalPathValue{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
		return &DeviceSpecUSBGuardInterface_FieldTerminalPathValue{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Interface: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecUSBGuardInterface_FieldPathArrayOfValues {
	fpaov := &DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
		return &DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
		return &DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Interface: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceSpecUSBGuardInterface_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceSpecUSBGuardInterface_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
		return &DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
		return &DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue{DeviceSpecUSBGuardInterface_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Interface: %d", fp.selector))
	}
}

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

// DeviceSpecUSBGuardInterface_FieldPathValue allows storing values for Interface fields according to their type
type DeviceSpecUSBGuardInterface_FieldPathValue interface {
	DeviceSpecUSBGuardInterface_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_USBGuard_Interface)
	CompareWith(*Device_Spec_USBGuard_Interface) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecUSBGuardInterface_FieldPathValue(pathStr, valueStr string) DeviceSpecUSBGuardInterface_FieldPathValue {
	fpv, err := ParseDeviceSpecUSBGuardInterface_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecUSBGuardInterface_FieldTerminalPathValue struct {
	DeviceSpecUSBGuardInterface_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuardInterface_FieldPathValue = (*DeviceSpecUSBGuardInterface_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Interface' as interface{}
func (fpv *DeviceSpecUSBGuardInterface_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecUSBGuardInterface_FieldTerminalPathValue) AsEqualsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceSpecUSBGuardInterface_FieldTerminalPathValue) AsOneOfValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object Interface
func (fpv *DeviceSpecUSBGuardInterface_FieldTerminalPathValue) SetTo(target **Device_Spec_USBGuard_Interface) {
	if *target == nil {
		*target = new(Device_Spec_USBGuard_Interface)
	}
	switch fpv.selector {
	case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
		(*target).Equals = fpv.value.([]string)
	case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
		(*target).OneOf = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_Interface: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseDeviceSpecUSBGuardInterface_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecUSBGuardInterface_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecUSBGuardInterface_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue struct {
	DeviceSpecUSBGuardInterface_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuardInterface_FieldPathArrayItemValue = (*DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Spec_USBGuard_Interface as interface{}
func (fpaiv *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue) AsEqualsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue) AsOneOfItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_USBGuard_Interface) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceSpecUSBGuardInterface_FieldPathArrayOfValues allows storing slice of values for Interface fields according to their type
type DeviceSpecUSBGuardInterface_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecUSBGuardInterface_FieldPath
}

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

func MustParseDeviceSpecUSBGuardInterface_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecUSBGuardInterface_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecUSBGuardInterface_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues struct {
	DeviceSpecUSBGuardInterface_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecUSBGuardInterface_FieldPathArrayOfValues = (*DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecUSBGuardInterface_FieldPathSelectorEquals:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues) AsEqualsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuardInterface_FieldTerminalPathArrayOfValues) AsOneOfArrayOfValues() ([][]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 DeviceSpecUSBGuardWhiteList_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceSpecUSBGuardWhiteList_FieldPathSelector
	Get(source *Device_Spec_USBGuard_WhiteList) []interface{}
	GetSingle(source *Device_Spec_USBGuard_WhiteList) (interface{}, bool)
	ClearValue(item *Device_Spec_USBGuard_WhiteList)

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

type DeviceSpecUSBGuardWhiteList_FieldPathSelector int32

const (
	DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName      DeviceSpecUSBGuardWhiteList_FieldPathSelector = 0
	DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId        DeviceSpecUSBGuardWhiteList_FieldPathSelector = 1
	DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort         DeviceSpecUSBGuardWhiteList_FieldPathSelector = 2
	DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface   DeviceSpecUSBGuardWhiteList_FieldPathSelector = 3
	DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType DeviceSpecUSBGuardWhiteList_FieldPathSelector = 4
)

func (s DeviceSpecUSBGuardWhiteList_FieldPathSelector) String() string {
	switch s {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		return "device_name"
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		return "device_id"
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return "via_port"
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return "with_interface"
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		return "with_connect_type"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", s))
	}
}

func BuildDeviceSpecUSBGuardWhiteList_FieldPath(fp gotenobject.RawFieldPath) (DeviceSpecUSBGuardWhiteList_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Spec_USBGuard_WhiteList")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "device_name", "deviceName", "device-name":
			return &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName}, nil
		case "device_id", "deviceId", "device-id":
			return &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId}, nil
		case "via_port", "viaPort", "via-port":
			return &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort}, nil
		case "with_interface", "withInterface", "with-interface":
			return &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface}, nil
		case "with_connect_type", "withConnectType", "with-connect-type":
			return &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType}, nil
		}
	} else {
		switch fp[0] {
		case "via_port", "viaPort", "via-port":
			if subpath, err := BuildDeviceSpecUSBGuardPort_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpecUSBGuardWhiteList_FieldSubPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort, subPath: subpath}, nil
			}
		case "with_interface", "withInterface", "with-interface":
			if subpath, err := BuildDeviceSpecUSBGuardInterface_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceSpecUSBGuardWhiteList_FieldSubPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Spec_USBGuard_WhiteList", fp)
}

func ParseDeviceSpecUSBGuardWhiteList_FieldPath(rawField string) (DeviceSpecUSBGuardWhiteList_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceSpecUSBGuardWhiteList_FieldPath(fp)
}

func MustParseDeviceSpecUSBGuardWhiteList_FieldPath(rawField string) DeviceSpecUSBGuardWhiteList_FieldPath {
	fp, err := ParseDeviceSpecUSBGuardWhiteList_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceSpecUSBGuardWhiteList_FieldTerminalPath struct {
	selector DeviceSpecUSBGuardWhiteList_FieldPathSelector
}

var _ DeviceSpecUSBGuardWhiteList_FieldPath = (*DeviceSpecUSBGuardWhiteList_FieldTerminalPath)(nil)

func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) Selector() DeviceSpecUSBGuardWhiteList_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Spec_USBGuard_WhiteList
func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) Get(source *Device_Spec_USBGuard_WhiteList) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
			values = append(values, source.DeviceName)
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
			values = append(values, source.DeviceId)
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
			if source.ViaPort != nil {
				values = append(values, source.ViaPort)
			}
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
			if source.WithInterface != nil {
				values = append(values, source.WithInterface)
			}
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
			values = append(values, source.WithConnectType)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Spec_USBGuard_WhiteList
func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) GetSingle(source *Device_Spec_USBGuard_WhiteList) (interface{}, bool) {
	switch fp.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		return source.GetDeviceName(), source != nil
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		return source.GetDeviceId(), source != nil
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		res := source.GetViaPort()
		return res, res != nil
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		res := source.GetWithInterface()
		return res, res != nil
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		return source.GetWithConnectType(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		return ""
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		return ""
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return (*Device_Spec_USBGuard_Port)(nil)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return (*Device_Spec_USBGuard_Interface)(nil)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fp.selector))
	}
}

func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) ClearValue(item *Device_Spec_USBGuard_WhiteList) {
	if item != nil {
		switch fp.selector {
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
			item.DeviceName = ""
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
			item.DeviceId = ""
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
			item.ViaPort = nil
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
			item.WithInterface = nil
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
			item.WithConnectType = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fp.selector))
		}
	}
}

func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Spec_USBGuard_WhiteList))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName ||
		fp.selector == DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId ||
		fp.selector == DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType
}

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

func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) WithIValue(value interface{}) DeviceSpecUSBGuardWhiteList_FieldPathValue {
	switch fp.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, value: value.(*Device_Spec_USBGuard_Port)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, value: value.(*Device_Spec_USBGuard_Interface)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fp.selector))
	}
}

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

func (fp *DeviceSpecUSBGuardWhiteList_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues {
	fpaov := &DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, values: values.([]*Device_Spec_USBGuard_Port)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, values: values.([]*Device_Spec_USBGuard_Interface)}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		return &DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues{DeviceSpecUSBGuardWhiteList_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type DeviceSpecUSBGuardWhiteList_FieldSubPath struct {
	selector DeviceSpecUSBGuardWhiteList_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceSpecUSBGuardWhiteList_FieldPath = (*DeviceSpecUSBGuardWhiteList_FieldSubPath)(nil)

func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) Selector() DeviceSpecUSBGuardWhiteList_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) AsViaPortSubPath() (DeviceSpecUSBGuardPort_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecUSBGuardPort_FieldPath)
	return res, ok
}
func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) AsWithInterfaceSubPath() (DeviceSpecUSBGuardInterface_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecUSBGuardInterface_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) ClearValue(item *Device_Spec_USBGuard_WhiteList) {
	if item != nil {
		switch fps.selector {
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
			fps.subPath.ClearValueRaw(item.ViaPort)
		case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
			fps.subPath.ClearValueRaw(item.WithInterface)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fps.selector))
		}
	}
}

func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Spec_USBGuard_WhiteList))
}

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

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

func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) WithIValue(value interface{}) DeviceSpecUSBGuardWhiteList_FieldPathValue {
	return &DeviceSpecUSBGuardWhiteList_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues {
	return &DeviceSpecUSBGuardWhiteList_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceSpecUSBGuardWhiteList_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceSpecUSBGuardWhiteList_FieldPathArrayItemValue {
	return &DeviceSpecUSBGuardWhiteList_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceSpecUSBGuardWhiteList_FieldPathValue allows storing values for WhiteList fields according to their type
type DeviceSpecUSBGuardWhiteList_FieldPathValue interface {
	DeviceSpecUSBGuardWhiteList_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Spec_USBGuard_WhiteList)
	CompareWith(*Device_Spec_USBGuard_WhiteList) (cmp int, comparable bool)
}

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

func MustParseDeviceSpecUSBGuardWhiteList_FieldPathValue(pathStr, valueStr string) DeviceSpecUSBGuardWhiteList_FieldPathValue {
	fpv, err := ParseDeviceSpecUSBGuardWhiteList_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue struct {
	DeviceSpecUSBGuardWhiteList_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuardWhiteList_FieldPathValue = (*DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WhiteList' as interface{}
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) AsDeviceNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) AsDeviceIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) AsViaPortValue() (*Device_Spec_USBGuard_Port, bool) {
	res, ok := fpv.value.(*Device_Spec_USBGuard_Port)
	return res, ok
}
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) AsWithInterfaceValue() (*Device_Spec_USBGuard_Interface, bool) {
	res, ok := fpv.value.(*Device_Spec_USBGuard_Interface)
	return res, ok
}
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) AsWithConnectTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object WhiteList
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) SetTo(target **Device_Spec_USBGuard_WhiteList) {
	if *target == nil {
		*target = new(Device_Spec_USBGuard_WhiteList)
	}
	switch fpv.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		(*target).DeviceName = fpv.value.(string)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		(*target).DeviceId = fpv.value.(string)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		(*target).ViaPort = fpv.value.(*Device_Spec_USBGuard_Port)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		(*target).WithInterface = fpv.value.(*Device_Spec_USBGuard_Interface)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		(*target).WithConnectType = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue' with the value under path in 'Device_Spec_USBGuard_WhiteList'.
func (fpv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathValue) CompareWith(source *Device_Spec_USBGuard_WhiteList) (int, bool) {
	switch fpv.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		leftValue := fpv.value.(string)
		rightValue := source.GetDeviceName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		leftValue := fpv.value.(string)
		rightValue := source.GetDeviceId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return 0, false
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return 0, false
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		leftValue := fpv.value.(string)
		rightValue := source.GetWithConnectType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fpv.selector))
	}
}

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

type DeviceSpecUSBGuardWhiteList_FieldSubPathValue struct {
	DeviceSpecUSBGuardWhiteList_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceSpecUSBGuardWhiteList_FieldPathValue = (*DeviceSpecUSBGuardWhiteList_FieldSubPathValue)(nil)

func (fpvs *DeviceSpecUSBGuardWhiteList_FieldSubPathValue) AsViaPortPathValue() (DeviceSpecUSBGuardPort_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecUSBGuardPort_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceSpecUSBGuardWhiteList_FieldSubPathValue) AsWithInterfacePathValue() (DeviceSpecUSBGuardInterface_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecUSBGuardInterface_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceSpecUSBGuardWhiteList_FieldSubPathValue) SetTo(target **Device_Spec_USBGuard_WhiteList) {
	if *target == nil {
		*target = new(Device_Spec_USBGuard_WhiteList)
	}
	switch fpvs.Selector() {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		fpvs.subPathValue.(DeviceSpecUSBGuardPort_FieldPathValue).SetTo(&(*target).ViaPort)
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		fpvs.subPathValue.(DeviceSpecUSBGuardInterface_FieldPathValue).SetTo(&(*target).WithInterface)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceSpecUSBGuardWhiteList_FieldSubPathValue) CompareWith(source *Device_Spec_USBGuard_WhiteList) (int, bool) {
	switch fpvs.Selector() {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return fpvs.subPathValue.(DeviceSpecUSBGuardPort_FieldPathValue).CompareWith(source.GetViaPort())
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return fpvs.subPathValue.(DeviceSpecUSBGuardInterface_FieldPathValue).CompareWith(source.GetWithInterface())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceSpecUSBGuardWhiteList_FieldPathArrayItemValue(pathStr, valueStr string) DeviceSpecUSBGuardWhiteList_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceSpecUSBGuardWhiteList_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayItemValue struct {
	DeviceSpecUSBGuardWhiteList_FieldTerminalPath
	value interface{}
}

var _ DeviceSpecUSBGuardWhiteList_FieldPathArrayItemValue = (*DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Spec_USBGuard_WhiteList) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WhiteList'
func (fpaiv *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Spec_USBGuard_WhiteList) bool {
	slice := fpaiv.DeviceSpecUSBGuardWhiteList_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 DeviceSpecUSBGuardWhiteList_FieldSubPathArrayItemValue struct {
	DeviceSpecUSBGuardWhiteList_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayItemValue) AsViaPortPathItemValue() (DeviceSpecUSBGuardPort_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecUSBGuardPort_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayItemValue) AsWithInterfacePathItemValue() (DeviceSpecUSBGuardInterface_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecUSBGuardInterface_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'WhiteList'
func (fpaivs *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayItemValue) ContainsValue(source *Device_Spec_USBGuard_WhiteList) bool {
	switch fpaivs.Selector() {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		return fpaivs.subPathItemValue.(DeviceSpecUSBGuardPort_FieldPathArrayItemValue).ContainsValue(source.GetViaPort())
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		return fpaivs.subPathItemValue.(DeviceSpecUSBGuardInterface_FieldPathArrayItemValue).ContainsValue(source.GetWithInterface())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Spec_USBGuard_WhiteList: %d", fpaivs.Selector()))
	}
}

// DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues allows storing slice of values for WhiteList fields according to their type
type DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceSpecUSBGuardWhiteList_FieldPath
}

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

func MustParseDeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues struct {
	DeviceSpecUSBGuardWhiteList_FieldTerminalPath
	values interface{}
}

var _ DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues = (*DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort:
		for _, v := range fpaov.values.([]*Device_Spec_USBGuard_Port) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface:
		for _, v := range fpaov.values.([]*Device_Spec_USBGuard_Interface) {
			values = append(values, v)
		}
	case DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues) AsDeviceNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues) AsDeviceIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues) AsViaPortArrayOfValues() ([]*Device_Spec_USBGuard_Port, bool) {
	res, ok := fpaov.values.([]*Device_Spec_USBGuard_Port)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues) AsWithInterfaceArrayOfValues() ([]*Device_Spec_USBGuard_Interface, bool) {
	res, ok := fpaov.values.([]*Device_Spec_USBGuard_Interface)
	return res, ok
}
func (fpaov *DeviceSpecUSBGuardWhiteList_FieldTerminalPathArrayOfValues) AsWithConnectTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type DeviceSpecUSBGuardWhiteList_FieldSubPathArrayOfValues struct {
	DeviceSpecUSBGuardWhiteList_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceSpecUSBGuardWhiteList_FieldPathArrayOfValues = (*DeviceSpecUSBGuardWhiteList_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayOfValues) AsViaPortPathArrayOfValues() (DeviceSpecUSBGuardPort_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecUSBGuardPort_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceSpecUSBGuardWhiteList_FieldSubPathArrayOfValues) AsWithInterfacePathArrayOfValues() (DeviceSpecUSBGuardInterface_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecUSBGuardInterface_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusAddress_FieldPathSelector int32

const (
	DeviceStatusAddress_FieldPathSelectorAddress DeviceStatusAddress_FieldPathSelector = 0
	DeviceStatusAddress_FieldPathSelectorType    DeviceStatusAddress_FieldPathSelector = 1
)

func (s DeviceStatusAddress_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusAddress_FieldPathSelectorAddress:
		return "address"
	case DeviceStatusAddress_FieldPathSelectorType:
		return "type"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Address: %d", s))
	}
}

func BuildDeviceStatusAddress_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusAddress_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_Address")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "address":
			return &DeviceStatusAddress_FieldTerminalPath{selector: DeviceStatusAddress_FieldPathSelectorAddress}, nil
		case "type":
			return &DeviceStatusAddress_FieldTerminalPath{selector: DeviceStatusAddress_FieldPathSelectorType}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_Address", fp)
}

func ParseDeviceStatusAddress_FieldPath(rawField string) (DeviceStatusAddress_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusAddress_FieldPath(fp)
}

func MustParseDeviceStatusAddress_FieldPath(rawField string) DeviceStatusAddress_FieldPath {
	fp, err := ParseDeviceStatusAddress_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusAddress_FieldTerminalPath struct {
	selector DeviceStatusAddress_FieldPathSelector
}

var _ DeviceStatusAddress_FieldPath = (*DeviceStatusAddress_FieldTerminalPath)(nil)

func (fp *DeviceStatusAddress_FieldTerminalPath) Selector() DeviceStatusAddress_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source Device_Status_Address
func (fp *DeviceStatusAddress_FieldTerminalPath) GetSingle(source *Device_Status_Address) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusAddress_FieldPathSelectorAddress:
		return source.GetAddress(), source != nil
	case DeviceStatusAddress_FieldPathSelectorType:
		return source.GetType(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Address: %d", fp.selector))
	}
}

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

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

func (fp *DeviceStatusAddress_FieldTerminalPath) ClearValue(item *Device_Status_Address) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusAddress_FieldPathSelectorAddress:
			item.Address = ""
		case DeviceStatusAddress_FieldPathSelectorType:
			item.Type = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_Address: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusAddress_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_Address))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusAddress_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusAddress_FieldPathSelectorAddress ||
		fp.selector == DeviceStatusAddress_FieldPathSelectorType
}

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

func (fp *DeviceStatusAddress_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusAddress_FieldPathValue {
	switch fp.selector {
	case DeviceStatusAddress_FieldPathSelectorAddress:
		return &DeviceStatusAddress_FieldTerminalPathValue{DeviceStatusAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusAddress_FieldPathSelectorType:
		return &DeviceStatusAddress_FieldTerminalPathValue{DeviceStatusAddress_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Address: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusAddress_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusAddress_FieldPathArrayOfValues {
	fpaov := &DeviceStatusAddress_FieldTerminalPathArrayOfValues{DeviceStatusAddress_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusAddress_FieldPathSelectorAddress:
		return &DeviceStatusAddress_FieldTerminalPathArrayOfValues{DeviceStatusAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusAddress_FieldPathSelectorType:
		return &DeviceStatusAddress_FieldTerminalPathArrayOfValues{DeviceStatusAddress_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Address: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusAddress_FieldPathValue allows storing values for Address fields according to their type
type DeviceStatusAddress_FieldPathValue interface {
	DeviceStatusAddress_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_Address)
	CompareWith(*Device_Status_Address) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusAddress_FieldPathValue(pathStr, valueStr string) DeviceStatusAddress_FieldPathValue {
	fpv, err := ParseDeviceStatusAddress_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusAddress_FieldTerminalPathValue struct {
	DeviceStatusAddress_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusAddress_FieldPathValue = (*DeviceStatusAddress_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Address
func (fpv *DeviceStatusAddress_FieldTerminalPathValue) SetTo(target **Device_Status_Address) {
	if *target == nil {
		*target = new(Device_Status_Address)
	}
	switch fpv.selector {
	case DeviceStatusAddress_FieldPathSelectorAddress:
		(*target).Address = fpv.value.(string)
	case DeviceStatusAddress_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Address: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseDeviceStatusAddress_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusAddress_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusAddress_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusAddress_FieldTerminalPathArrayItemValue struct {
	DeviceStatusAddress_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusAddress_FieldPathArrayItemValue = (*DeviceStatusAddress_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusAddress_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_Address) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusAddress_FieldPathArrayOfValues allows storing slice of values for Address fields according to their type
type DeviceStatusAddress_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusAddress_FieldPath
}

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

func MustParseDeviceStatusAddress_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusAddress_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusAddress_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusAddress_FieldTerminalPathArrayOfValues struct {
	DeviceStatusAddress_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusAddress_FieldPathArrayOfValues = (*DeviceStatusAddress_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusAddress_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusAddress_FieldPathSelectorAddress:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusAddress_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusAddress_FieldTerminalPathArrayOfValues) AsAddressArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusAddress_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]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 DeviceStatusCondition_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusCondition_FieldPathSelector
	Get(source *Device_Status_Condition) []interface{}
	GetSingle(source *Device_Status_Condition) (interface{}, bool)
	ClearValue(item *Device_Status_Condition)

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

type DeviceStatusCondition_FieldPathSelector int32

const (
	DeviceStatusCondition_FieldPathSelectorMessage            DeviceStatusCondition_FieldPathSelector = 0
	DeviceStatusCondition_FieldPathSelectorReason             DeviceStatusCondition_FieldPathSelector = 1
	DeviceStatusCondition_FieldPathSelectorStatus             DeviceStatusCondition_FieldPathSelector = 2
	DeviceStatusCondition_FieldPathSelectorType               DeviceStatusCondition_FieldPathSelector = 3
	DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime  DeviceStatusCondition_FieldPathSelector = 4
	DeviceStatusCondition_FieldPathSelectorLastTransitionTime DeviceStatusCondition_FieldPathSelector = 5
)

func (s DeviceStatusCondition_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		return "message"
	case DeviceStatusCondition_FieldPathSelectorReason:
		return "reason"
	case DeviceStatusCondition_FieldPathSelectorStatus:
		return "status"
	case DeviceStatusCondition_FieldPathSelectorType:
		return "type"
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		return "last_heart_beat_time"
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		return "last_transition_time"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", s))
	}
}

func BuildDeviceStatusCondition_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusCondition_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_Condition")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "message":
			return &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorMessage}, nil
		case "reason":
			return &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorReason}, nil
		case "status":
			return &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorStatus}, nil
		case "type":
			return &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorType}, nil
		case "last_heart_beat_time", "lastHeartBeatTime", "last-heart-beat-time":
			return &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime}, nil
		case "last_transition_time", "lastTransitionTime", "last-transition-time":
			return &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorLastTransitionTime}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_Condition", fp)
}

func ParseDeviceStatusCondition_FieldPath(rawField string) (DeviceStatusCondition_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusCondition_FieldPath(fp)
}

func MustParseDeviceStatusCondition_FieldPath(rawField string) DeviceStatusCondition_FieldPath {
	fp, err := ParseDeviceStatusCondition_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusCondition_FieldTerminalPath struct {
	selector DeviceStatusCondition_FieldPathSelector
}

var _ DeviceStatusCondition_FieldPath = (*DeviceStatusCondition_FieldTerminalPath)(nil)

func (fp *DeviceStatusCondition_FieldTerminalPath) Selector() DeviceStatusCondition_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_Condition
func (fp *DeviceStatusCondition_FieldTerminalPath) Get(source *Device_Status_Condition) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusCondition_FieldPathSelectorMessage:
			values = append(values, source.Message)
		case DeviceStatusCondition_FieldPathSelectorReason:
			values = append(values, source.Reason)
		case DeviceStatusCondition_FieldPathSelectorStatus:
			values = append(values, source.Status)
		case DeviceStatusCondition_FieldPathSelectorType:
			values = append(values, source.Type)
		case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
			if source.LastHeartBeatTime != nil {
				values = append(values, source.LastHeartBeatTime)
			}
		case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
			if source.LastTransitionTime != nil {
				values = append(values, source.LastTransitionTime)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_Condition
func (fp *DeviceStatusCondition_FieldTerminalPath) GetSingle(source *Device_Status_Condition) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		return source.GetMessage(), source != nil
	case DeviceStatusCondition_FieldPathSelectorReason:
		return source.GetReason(), source != nil
	case DeviceStatusCondition_FieldPathSelectorStatus:
		return source.GetStatus(), source != nil
	case DeviceStatusCondition_FieldPathSelectorType:
		return source.GetType(), source != nil
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		res := source.GetLastHeartBeatTime()
		return res, res != nil
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		res := source.GetLastTransitionTime()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusCondition_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		return ""
	case DeviceStatusCondition_FieldPathSelectorReason:
		return ""
	case DeviceStatusCondition_FieldPathSelectorStatus:
		return ""
	case DeviceStatusCondition_FieldPathSelectorType:
		return ""
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		return (*timestamppb.Timestamp)(nil)
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fp.selector))
	}
}

func (fp *DeviceStatusCondition_FieldTerminalPath) ClearValue(item *Device_Status_Condition) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusCondition_FieldPathSelectorMessage:
			item.Message = ""
		case DeviceStatusCondition_FieldPathSelectorReason:
			item.Reason = ""
		case DeviceStatusCondition_FieldPathSelectorStatus:
			item.Status = ""
		case DeviceStatusCondition_FieldPathSelectorType:
			item.Type = ""
		case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
			item.LastHeartBeatTime = nil
		case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
			item.LastTransitionTime = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusCondition_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_Condition))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusCondition_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusCondition_FieldPathSelectorMessage ||
		fp.selector == DeviceStatusCondition_FieldPathSelectorReason ||
		fp.selector == DeviceStatusCondition_FieldPathSelectorStatus ||
		fp.selector == DeviceStatusCondition_FieldPathSelectorType ||
		fp.selector == DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime ||
		fp.selector == DeviceStatusCondition_FieldPathSelectorLastTransitionTime
}

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

func (fp *DeviceStatusCondition_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusCondition_FieldPathValue {
	switch fp.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		return &DeviceStatusCondition_FieldTerminalPathValue{DeviceStatusCondition_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusCondition_FieldPathSelectorReason:
		return &DeviceStatusCondition_FieldTerminalPathValue{DeviceStatusCondition_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusCondition_FieldPathSelectorStatus:
		return &DeviceStatusCondition_FieldTerminalPathValue{DeviceStatusCondition_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusCondition_FieldPathSelectorType:
		return &DeviceStatusCondition_FieldTerminalPathValue{DeviceStatusCondition_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		return &DeviceStatusCondition_FieldTerminalPathValue{DeviceStatusCondition_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		return &DeviceStatusCondition_FieldTerminalPathValue{DeviceStatusCondition_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusCondition_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusCondition_FieldPathArrayOfValues {
	fpaov := &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		return &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusCondition_FieldPathSelectorReason:
		return &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusCondition_FieldPathSelectorStatus:
		return &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusCondition_FieldPathSelectorType:
		return &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		return &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		return &DeviceStatusCondition_FieldTerminalPathArrayOfValues{DeviceStatusCondition_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusCondition_FieldPathValue allows storing values for Condition fields according to their type
type DeviceStatusCondition_FieldPathValue interface {
	DeviceStatusCondition_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_Condition)
	CompareWith(*Device_Status_Condition) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusCondition_FieldPathValue(pathStr, valueStr string) DeviceStatusCondition_FieldPathValue {
	fpv, err := ParseDeviceStatusCondition_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusCondition_FieldTerminalPathValue struct {
	DeviceStatusCondition_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusCondition_FieldPathValue = (*DeviceStatusCondition_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Condition' as interface{}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) AsMessageValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) AsReasonValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) AsStatusValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) AsTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) AsLastHeartBeatTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) AsLastTransitionTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object Condition
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) SetTo(target **Device_Status_Condition) {
	if *target == nil {
		*target = new(Device_Status_Condition)
	}
	switch fpv.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		(*target).Message = fpv.value.(string)
	case DeviceStatusCondition_FieldPathSelectorReason:
		(*target).Reason = fpv.value.(string)
	case DeviceStatusCondition_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(string)
	case DeviceStatusCondition_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		(*target).LastHeartBeatTime = fpv.value.(*timestamppb.Timestamp)
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		(*target).LastTransitionTime = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusCondition_FieldTerminalPathValue' with the value under path in 'Device_Status_Condition'.
func (fpv *DeviceStatusCondition_FieldTerminalPathValue) CompareWith(source *Device_Status_Condition) (int, bool) {
	switch fpv.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		leftValue := fpv.value.(string)
		rightValue := source.GetMessage()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusCondition_FieldPathSelectorReason:
		leftValue := fpv.value.(string)
		rightValue := source.GetReason()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusCondition_FieldPathSelectorStatus:
		leftValue := fpv.value.(string)
		rightValue := source.GetStatus()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusCondition_FieldPathSelectorType:
		leftValue := fpv.value.(string)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetLastHeartBeatTime()
		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 DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetLastTransitionTime()
		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
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_Condition: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusCondition_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusCondition_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusCondition_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusCondition_FieldTerminalPathArrayItemValue struct {
	DeviceStatusCondition_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusCondition_FieldPathArrayItemValue = (*DeviceStatusCondition_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusCondition_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_Condition) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusCondition_FieldPathArrayOfValues allows storing slice of values for Condition fields according to their type
type DeviceStatusCondition_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusCondition_FieldPath
}

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

func MustParseDeviceStatusCondition_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusCondition_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusCondition_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusCondition_FieldTerminalPathArrayOfValues struct {
	DeviceStatusCondition_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusCondition_FieldPathArrayOfValues = (*DeviceStatusCondition_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusCondition_FieldPathSelectorMessage:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusCondition_FieldPathSelectorReason:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusCondition_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusCondition_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case DeviceStatusCondition_FieldPathSelectorLastTransitionTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) AsMessageArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) AsReasonArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) AsLastHeartBeatTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *DeviceStatusCondition_FieldTerminalPathArrayOfValues) AsLastTransitionTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

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

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

type DeviceStatusNetworkConfigState_FieldPathSelector int32

const (
	DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource  DeviceStatusNetworkConfigState_FieldPathSelector = 0
	DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource DeviceStatusNetworkConfigState_FieldPathSelector = 1
	DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError  DeviceStatusNetworkConfigState_FieldPathSelector = 2
	DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig       DeviceStatusNetworkConfigState_FieldPathSelector = 3
	DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig        DeviceStatusNetworkConfigState_FieldPathSelector = 4
	DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig       DeviceStatusNetworkConfigState_FieldPathSelector = 5
)

func (s DeviceStatusNetworkConfigState_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		return "active_network_config_source"
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		return "desired_network_config_source"
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		return "desired_network_config_error"
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		return "default_netplan_config"
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		return "active_netplan_config"
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		return "desired_netplan_config"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", s))
	}
}

func BuildDeviceStatusNetworkConfigState_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusNetworkConfigState_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_NetworkConfigState")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "active_network_config_source", "activeNetworkConfigSource", "active-network-config-source":
			return &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource}, nil
		case "desired_network_config_source", "desiredNetworkConfigSource", "desired-network-config-source":
			return &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource}, nil
		case "desired_network_config_error", "desiredNetworkConfigError", "desired-network-config-error":
			return &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError}, nil
		case "default_netplan_config", "defaultNetplanConfig", "default-netplan-config":
			return &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig}, nil
		case "active_netplan_config", "activeNetplanConfig", "active-netplan-config":
			return &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig}, nil
		case "desired_netplan_config", "desiredNetplanConfig", "desired-netplan-config":
			return &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_NetworkConfigState", fp)
}

func ParseDeviceStatusNetworkConfigState_FieldPath(rawField string) (DeviceStatusNetworkConfigState_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusNetworkConfigState_FieldPath(fp)
}

func MustParseDeviceStatusNetworkConfigState_FieldPath(rawField string) DeviceStatusNetworkConfigState_FieldPath {
	fp, err := ParseDeviceStatusNetworkConfigState_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusNetworkConfigState_FieldTerminalPath struct {
	selector DeviceStatusNetworkConfigState_FieldPathSelector
}

var _ DeviceStatusNetworkConfigState_FieldPath = (*DeviceStatusNetworkConfigState_FieldTerminalPath)(nil)

func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) Selector() DeviceStatusNetworkConfigState_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_NetworkConfigState
func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) Get(source *Device_Status_NetworkConfigState) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
			values = append(values, source.ActiveNetworkConfigSource)
		case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
			values = append(values, source.DesiredNetworkConfigSource)
		case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
			values = append(values, source.DesiredNetworkConfigError)
		case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
			values = append(values, source.DefaultNetplanConfig)
		case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
			values = append(values, source.ActiveNetplanConfig)
		case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
			values = append(values, source.DesiredNetplanConfig)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_NetworkConfigState
func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) GetSingle(source *Device_Status_NetworkConfigState) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		return source.GetActiveNetworkConfigSource(), source != nil
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		return source.GetDesiredNetworkConfigSource(), source != nil
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		return source.GetDesiredNetworkConfigError(), source != nil
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		return source.GetDefaultNetplanConfig(), source != nil
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		return source.GetActiveNetplanConfig(), source != nil
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		return source.GetDesiredNetplanConfig(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		return Device_Status_NetworkConfigState_UNKNOWN
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		return Device_Status_NetworkConfigState_UNKNOWN
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		return ""
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		return ""
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		return ""
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fp.selector))
	}
}

func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) ClearValue(item *Device_Status_NetworkConfigState) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
			item.ActiveNetworkConfigSource = Device_Status_NetworkConfigState_UNKNOWN
		case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
			item.DesiredNetworkConfigSource = Device_Status_NetworkConfigState_UNKNOWN
		case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
			item.DesiredNetworkConfigError = ""
		case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
			item.DefaultNetplanConfig = ""
		case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
			item.ActiveNetplanConfig = ""
		case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
			item.DesiredNetplanConfig = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_NetworkConfigState))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource ||
		fp.selector == DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource ||
		fp.selector == DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError ||
		fp.selector == DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig ||
		fp.selector == DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig ||
		fp.selector == DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig
}

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

func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusNetworkConfigState_FieldPathValue {
	switch fp.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathValue{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, value: value.(Device_Status_NetworkConfigState_NetworkConfigSource)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathValue{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, value: value.(Device_Status_NetworkConfigState_NetworkConfigSource)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathValue{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathValue{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathValue{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathValue{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusNetworkConfigState_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusNetworkConfigState_FieldPathArrayOfValues {
	fpaov := &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, values: values.([]Device_Status_NetworkConfigState_NetworkConfigSource)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, values: values.([]Device_Status_NetworkConfigState_NetworkConfigSource)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		return &DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues{DeviceStatusNetworkConfigState_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusNetworkConfigState_FieldPathValue allows storing values for NetworkConfigState fields according to their type
type DeviceStatusNetworkConfigState_FieldPathValue interface {
	DeviceStatusNetworkConfigState_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_NetworkConfigState)
	CompareWith(*Device_Status_NetworkConfigState) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusNetworkConfigState_FieldPathValue(pathStr, valueStr string) DeviceStatusNetworkConfigState_FieldPathValue {
	fpv, err := ParseDeviceStatusNetworkConfigState_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusNetworkConfigState_FieldTerminalPathValue struct {
	DeviceStatusNetworkConfigState_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusNetworkConfigState_FieldPathValue = (*DeviceStatusNetworkConfigState_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NetworkConfigState' as interface{}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) AsActiveNetworkConfigSourceValue() (Device_Status_NetworkConfigState_NetworkConfigSource, bool) {
	res, ok := fpv.value.(Device_Status_NetworkConfigState_NetworkConfigSource)
	return res, ok
}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) AsDesiredNetworkConfigSourceValue() (Device_Status_NetworkConfigState_NetworkConfigSource, bool) {
	res, ok := fpv.value.(Device_Status_NetworkConfigState_NetworkConfigSource)
	return res, ok
}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) AsDesiredNetworkConfigErrorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) AsDefaultNetplanConfigValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) AsActiveNetplanConfigValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) AsDesiredNetplanConfigValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object NetworkConfigState
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) SetTo(target **Device_Status_NetworkConfigState) {
	if *target == nil {
		*target = new(Device_Status_NetworkConfigState)
	}
	switch fpv.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		(*target).ActiveNetworkConfigSource = fpv.value.(Device_Status_NetworkConfigState_NetworkConfigSource)
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		(*target).DesiredNetworkConfigSource = fpv.value.(Device_Status_NetworkConfigState_NetworkConfigSource)
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		(*target).DesiredNetworkConfigError = fpv.value.(string)
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		(*target).DefaultNetplanConfig = fpv.value.(string)
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		(*target).ActiveNetplanConfig = fpv.value.(string)
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		(*target).DesiredNetplanConfig = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusNetworkConfigState_FieldTerminalPathValue' with the value under path in 'Device_Status_NetworkConfigState'.
func (fpv *DeviceStatusNetworkConfigState_FieldTerminalPathValue) CompareWith(source *Device_Status_NetworkConfigState) (int, bool) {
	switch fpv.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		leftValue := fpv.value.(Device_Status_NetworkConfigState_NetworkConfigSource)
		rightValue := source.GetActiveNetworkConfigSource()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		leftValue := fpv.value.(Device_Status_NetworkConfigState_NetworkConfigSource)
		rightValue := source.GetDesiredNetworkConfigSource()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		leftValue := fpv.value.(string)
		rightValue := source.GetDesiredNetworkConfigError()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		leftValue := fpv.value.(string)
		rightValue := source.GetDefaultNetplanConfig()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		leftValue := fpv.value.(string)
		rightValue := source.GetActiveNetplanConfig()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		leftValue := fpv.value.(string)
		rightValue := source.GetDesiredNetplanConfig()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NetworkConfigState: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusNetworkConfigState_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusNetworkConfigState_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusNetworkConfigState_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusNetworkConfigState_FieldTerminalPathArrayItemValue struct {
	DeviceStatusNetworkConfigState_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusNetworkConfigState_FieldPathArrayItemValue = (*DeviceStatusNetworkConfigState_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusNetworkConfigState_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_NetworkConfigState) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusNetworkConfigState_FieldPathArrayOfValues allows storing slice of values for NetworkConfigState fields according to their type
type DeviceStatusNetworkConfigState_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusNetworkConfigState_FieldPath
}

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

func MustParseDeviceStatusNetworkConfigState_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusNetworkConfigState_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusNetworkConfigState_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues struct {
	DeviceStatusNetworkConfigState_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusNetworkConfigState_FieldPathArrayOfValues = (*DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource:
		for _, v := range fpaov.values.([]Device_Status_NetworkConfigState_NetworkConfigSource) {
			values = append(values, v)
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource:
		for _, v := range fpaov.values.([]Device_Status_NetworkConfigState_NetworkConfigSource) {
			values = append(values, v)
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) AsActiveNetworkConfigSourceArrayOfValues() ([]Device_Status_NetworkConfigState_NetworkConfigSource, bool) {
	res, ok := fpaov.values.([]Device_Status_NetworkConfigState_NetworkConfigSource)
	return res, ok
}
func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) AsDesiredNetworkConfigSourceArrayOfValues() ([]Device_Status_NetworkConfigState_NetworkConfigSource, bool) {
	res, ok := fpaov.values.([]Device_Status_NetworkConfigState_NetworkConfigSource)
	return res, ok
}
func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) AsDesiredNetworkConfigErrorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) AsDefaultNetplanConfigArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) AsActiveNetplanConfigArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNetworkConfigState_FieldTerminalPathArrayOfValues) AsDesiredNetplanConfigArrayOfValues() ([]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 DeviceStatusProxyConfigStatus_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusProxyConfigStatus_FieldPathSelector
	Get(source *Device_Status_ProxyConfigStatus) []interface{}
	GetSingle(source *Device_Status_ProxyConfigStatus) (interface{}, bool)
	ClearValue(item *Device_Status_ProxyConfigStatus)

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

type DeviceStatusProxyConfigStatus_FieldPathSelector int32

const (
	DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource  DeviceStatusProxyConfigStatus_FieldPathSelector = 0
	DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource DeviceStatusProxyConfigStatus_FieldPathSelector = 1
	DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError    DeviceStatusProxyConfigStatus_FieldPathSelector = 2
	DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig       DeviceStatusProxyConfigStatus_FieldPathSelector = 3
	DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig        DeviceStatusProxyConfigStatus_FieldPathSelector = 4
	DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig           DeviceStatusProxyConfigStatus_FieldPathSelector = 5
)

func (s DeviceStatusProxyConfigStatus_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		return "active_config_source"
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		return "desired_config_source"
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		return "proxy_config_error"
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return "default_config"
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return "active_config"
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return "api_config"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", s))
	}
}

func BuildDeviceStatusProxyConfigStatus_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusProxyConfigStatus_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_ProxyConfigStatus")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "active_config_source", "activeConfigSource", "active-config-source":
			return &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource}, nil
		case "desired_config_source", "desiredConfigSource", "desired-config-source":
			return &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource}, nil
		case "proxy_config_error", "proxyConfigError", "proxy-config-error":
			return &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError}, nil
		case "default_config", "defaultConfig", "default-config":
			return &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig}, nil
		case "active_config", "activeConfig", "active-config":
			return &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig}, nil
		case "api_config", "apiConfig", "api-config":
			return &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig}, nil
		}
	} else {
		switch fp[0] {
		case "default_config", "defaultConfig", "default-config":
			if subpath, err := BuildDeviceSpecProxyConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusProxyConfigStatus_FieldSubPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig, subPath: subpath}, nil
			}
		case "active_config", "activeConfig", "active-config":
			if subpath, err := BuildDeviceSpecProxyConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusProxyConfigStatus_FieldSubPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig, subPath: subpath}, nil
			}
		case "api_config", "apiConfig", "api-config":
			if subpath, err := BuildDeviceSpecProxyConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusProxyConfigStatus_FieldSubPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_ProxyConfigStatus", fp)
}

func ParseDeviceStatusProxyConfigStatus_FieldPath(rawField string) (DeviceStatusProxyConfigStatus_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusProxyConfigStatus_FieldPath(fp)
}

func MustParseDeviceStatusProxyConfigStatus_FieldPath(rawField string) DeviceStatusProxyConfigStatus_FieldPath {
	fp, err := ParseDeviceStatusProxyConfigStatus_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusProxyConfigStatus_FieldTerminalPath struct {
	selector DeviceStatusProxyConfigStatus_FieldPathSelector
}

var _ DeviceStatusProxyConfigStatus_FieldPath = (*DeviceStatusProxyConfigStatus_FieldTerminalPath)(nil)

func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) Selector() DeviceStatusProxyConfigStatus_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_ProxyConfigStatus
func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) Get(source *Device_Status_ProxyConfigStatus) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
			values = append(values, source.ActiveConfigSource)
		case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
			values = append(values, source.DesiredConfigSource)
		case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
			values = append(values, source.ProxyConfigError)
		case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
			if source.DefaultConfig != nil {
				values = append(values, source.DefaultConfig)
			}
		case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
			if source.ActiveConfig != nil {
				values = append(values, source.ActiveConfig)
			}
		case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
			if source.ApiConfig != nil {
				values = append(values, source.ApiConfig)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_ProxyConfigStatus
func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) GetSingle(source *Device_Status_ProxyConfigStatus) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		return source.GetActiveConfigSource(), source != nil
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		return source.GetDesiredConfigSource(), source != nil
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		return source.GetProxyConfigError(), source != nil
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		res := source.GetDefaultConfig()
		return res, res != nil
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		res := source.GetActiveConfig()
		return res, res != nil
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		res := source.GetApiConfig()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		return Device_Status_ProxyConfigStatus_NO_CONFIG
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		return Device_Status_ProxyConfigStatus_NO_CONFIG
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		return ""
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return (*Device_Spec_ProxyConfig)(nil)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return (*Device_Spec_ProxyConfig)(nil)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return (*Device_Spec_ProxyConfig)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) ClearValue(item *Device_Status_ProxyConfigStatus) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
			item.ActiveConfigSource = Device_Status_ProxyConfigStatus_NO_CONFIG
		case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
			item.DesiredConfigSource = Device_Status_ProxyConfigStatus_NO_CONFIG
		case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
			item.ProxyConfigError = ""
		case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
			item.DefaultConfig = nil
		case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
			item.ActiveConfig = nil
		case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
			item.ApiConfig = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_ProxyConfigStatus))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource ||
		fp.selector == DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource ||
		fp.selector == DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError
}

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

func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusProxyConfigStatus_FieldPathValue {
	switch fp.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathValue{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, value: value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathValue{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, value: value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathValue{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathValue{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, value: value.(*Device_Spec_ProxyConfig)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathValue{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, value: value.(*Device_Spec_ProxyConfig)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathValue{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, value: value.(*Device_Spec_ProxyConfig)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusProxyConfigStatus_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusProxyConfigStatus_FieldPathArrayOfValues {
	fpaov := &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, values: values.([]Device_Status_ProxyConfigStatus_ProxyConfigSource)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, values: values.([]Device_Status_ProxyConfigStatus_ProxyConfigSource)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, values: values.([]*Device_Spec_ProxyConfig)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, values: values.([]*Device_Spec_ProxyConfig)}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return &DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues{DeviceStatusProxyConfigStatus_FieldTerminalPath: *fp, values: values.([]*Device_Spec_ProxyConfig)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type DeviceStatusProxyConfigStatus_FieldSubPath struct {
	selector DeviceStatusProxyConfigStatus_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusProxyConfigStatus_FieldPath = (*DeviceStatusProxyConfigStatus_FieldSubPath)(nil)

func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) Selector() DeviceStatusProxyConfigStatus_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) AsDefaultConfigSubPath() (DeviceSpecProxyConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecProxyConfig_FieldPath)
	return res, ok
}
func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) AsActiveConfigSubPath() (DeviceSpecProxyConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecProxyConfig_FieldPath)
	return res, ok
}
func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) AsApiConfigSubPath() (DeviceSpecProxyConfig_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceSpecProxyConfig_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Device_Status_ProxyConfigStatus
func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) Get(source *Device_Status_ProxyConfigStatus) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		values = append(values, fps.subPath.GetRaw(source.GetDefaultConfig())...)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		values = append(values, fps.subPath.GetRaw(source.GetActiveConfig())...)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		values = append(values, fps.subPath.GetRaw(source.GetApiConfig())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Device_Status_ProxyConfigStatus
func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) GetSingle(source *Device_Status_ProxyConfigStatus) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		if source.GetDefaultConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDefaultConfig())
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		if source.GetActiveConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetActiveConfig())
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		if source.GetApiConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetApiConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fps.selector))
	}
}

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

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

func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) ClearValue(item *Device_Status_ProxyConfigStatus) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
			fps.subPath.ClearValueRaw(item.DefaultConfig)
		case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
			fps.subPath.ClearValueRaw(item.ActiveConfig)
		case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
			fps.subPath.ClearValueRaw(item.ApiConfig)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_ProxyConfigStatus))
}

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

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

func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) WithIValue(value interface{}) DeviceStatusProxyConfigStatus_FieldPathValue {
	return &DeviceStatusProxyConfigStatus_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusProxyConfigStatus_FieldPathArrayOfValues {
	return &DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatusProxyConfigStatus_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusProxyConfigStatus_FieldPathArrayItemValue {
	return &DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceStatusProxyConfigStatus_FieldPathValue allows storing values for ProxyConfigStatus fields according to their type
type DeviceStatusProxyConfigStatus_FieldPathValue interface {
	DeviceStatusProxyConfigStatus_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_ProxyConfigStatus)
	CompareWith(*Device_Status_ProxyConfigStatus) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusProxyConfigStatus_FieldPathValue(pathStr, valueStr string) DeviceStatusProxyConfigStatus_FieldPathValue {
	fpv, err := ParseDeviceStatusProxyConfigStatus_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusProxyConfigStatus_FieldTerminalPathValue struct {
	DeviceStatusProxyConfigStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusProxyConfigStatus_FieldPathValue = (*DeviceStatusProxyConfigStatus_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProxyConfigStatus' as interface{}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) AsActiveConfigSourceValue() (Device_Status_ProxyConfigStatus_ProxyConfigSource, bool) {
	res, ok := fpv.value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)
	return res, ok
}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) AsDesiredConfigSourceValue() (Device_Status_ProxyConfigStatus_ProxyConfigSource, bool) {
	res, ok := fpv.value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)
	return res, ok
}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) AsProxyConfigErrorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) AsDefaultConfigValue() (*Device_Spec_ProxyConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_ProxyConfig)
	return res, ok
}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) AsActiveConfigValue() (*Device_Spec_ProxyConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_ProxyConfig)
	return res, ok
}
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) AsApiConfigValue() (*Device_Spec_ProxyConfig, bool) {
	res, ok := fpv.value.(*Device_Spec_ProxyConfig)
	return res, ok
}

// SetTo stores value for selected field for object ProxyConfigStatus
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) SetTo(target **Device_Status_ProxyConfigStatus) {
	if *target == nil {
		*target = new(Device_Status_ProxyConfigStatus)
	}
	switch fpv.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		(*target).ActiveConfigSource = fpv.value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		(*target).DesiredConfigSource = fpv.value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		(*target).ProxyConfigError = fpv.value.(string)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		(*target).DefaultConfig = fpv.value.(*Device_Spec_ProxyConfig)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		(*target).ActiveConfig = fpv.value.(*Device_Spec_ProxyConfig)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		(*target).ApiConfig = fpv.value.(*Device_Spec_ProxyConfig)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusProxyConfigStatus_FieldTerminalPathValue' with the value under path in 'Device_Status_ProxyConfigStatus'.
func (fpv *DeviceStatusProxyConfigStatus_FieldTerminalPathValue) CompareWith(source *Device_Status_ProxyConfigStatus) (int, bool) {
	switch fpv.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		leftValue := fpv.value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)
		rightValue := source.GetActiveConfigSource()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		leftValue := fpv.value.(Device_Status_ProxyConfigStatus_ProxyConfigSource)
		rightValue := source.GetDesiredConfigSource()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		leftValue := fpv.value.(string)
		rightValue := source.GetProxyConfigError()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return 0, false
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return 0, false
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fpv.selector))
	}
}

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

type DeviceStatusProxyConfigStatus_FieldSubPathValue struct {
	DeviceStatusProxyConfigStatus_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusProxyConfigStatus_FieldPathValue = (*DeviceStatusProxyConfigStatus_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusProxyConfigStatus_FieldSubPathValue) AsDefaultConfigPathValue() (DeviceSpecProxyConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusProxyConfigStatus_FieldSubPathValue) AsActiveConfigPathValue() (DeviceSpecProxyConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusProxyConfigStatus_FieldSubPathValue) AsApiConfigPathValue() (DeviceSpecProxyConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusProxyConfigStatus_FieldSubPathValue) SetTo(target **Device_Status_ProxyConfigStatus) {
	if *target == nil {
		*target = new(Device_Status_ProxyConfigStatus)
	}
	switch fpvs.Selector() {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).SetTo(&(*target).DefaultConfig)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).SetTo(&(*target).ActiveConfig)
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).SetTo(&(*target).ApiConfig)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceStatusProxyConfigStatus_FieldSubPathValue) CompareWith(source *Device_Status_ProxyConfigStatus) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).CompareWith(source.GetDefaultConfig())
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).CompareWith(source.GetActiveConfig())
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return fpvs.subPathValue.(DeviceSpecProxyConfig_FieldPathValue).CompareWith(source.GetApiConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceStatusProxyConfigStatus_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusProxyConfigStatus_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusProxyConfigStatus_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusProxyConfigStatus_FieldTerminalPathArrayItemValue struct {
	DeviceStatusProxyConfigStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusProxyConfigStatus_FieldPathArrayItemValue = (*DeviceStatusProxyConfigStatus_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_ProxyConfigStatus) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ProxyConfigStatus'
func (fpaiv *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_ProxyConfigStatus) bool {
	slice := fpaiv.DeviceStatusProxyConfigStatus_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 DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue struct {
	DeviceStatusProxyConfigStatus_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue) AsDefaultConfigPathItemValue() (DeviceSpecProxyConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue) AsActiveConfigPathItemValue() (DeviceSpecProxyConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue) AsApiConfigPathItemValue() (DeviceSpecProxyConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ProxyConfigStatus'
func (fpaivs *DeviceStatusProxyConfigStatus_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_ProxyConfigStatus) bool {
	switch fpaivs.Selector() {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		return fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue).ContainsValue(source.GetDefaultConfig())
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		return fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue).ContainsValue(source.GetActiveConfig())
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		return fpaivs.subPathItemValue.(DeviceSpecProxyConfig_FieldPathArrayItemValue).ContainsValue(source.GetApiConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_ProxyConfigStatus: %d", fpaivs.Selector()))
	}
}

// DeviceStatusProxyConfigStatus_FieldPathArrayOfValues allows storing slice of values for ProxyConfigStatus fields according to their type
type DeviceStatusProxyConfigStatus_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusProxyConfigStatus_FieldPath
}

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

func MustParseDeviceStatusProxyConfigStatus_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusProxyConfigStatus_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusProxyConfigStatus_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues struct {
	DeviceStatusProxyConfigStatus_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusProxyConfigStatus_FieldPathArrayOfValues = (*DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource:
		for _, v := range fpaov.values.([]Device_Status_ProxyConfigStatus_ProxyConfigSource) {
			values = append(values, v)
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource:
		for _, v := range fpaov.values.([]Device_Status_ProxyConfigStatus_ProxyConfigSource) {
			values = append(values, v)
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig:
		for _, v := range fpaov.values.([]*Device_Spec_ProxyConfig) {
			values = append(values, v)
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig:
		for _, v := range fpaov.values.([]*Device_Spec_ProxyConfig) {
			values = append(values, v)
		}
	case DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig:
		for _, v := range fpaov.values.([]*Device_Spec_ProxyConfig) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) AsActiveConfigSourceArrayOfValues() ([]Device_Status_ProxyConfigStatus_ProxyConfigSource, bool) {
	res, ok := fpaov.values.([]Device_Status_ProxyConfigStatus_ProxyConfigSource)
	return res, ok
}
func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) AsDesiredConfigSourceArrayOfValues() ([]Device_Status_ProxyConfigStatus_ProxyConfigSource, bool) {
	res, ok := fpaov.values.([]Device_Status_ProxyConfigStatus_ProxyConfigSource)
	return res, ok
}
func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) AsProxyConfigErrorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) AsDefaultConfigArrayOfValues() ([]*Device_Spec_ProxyConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_ProxyConfig)
	return res, ok
}
func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) AsActiveConfigArrayOfValues() ([]*Device_Spec_ProxyConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_ProxyConfig)
	return res, ok
}
func (fpaov *DeviceStatusProxyConfigStatus_FieldTerminalPathArrayOfValues) AsApiConfigArrayOfValues() ([]*Device_Spec_ProxyConfig, bool) {
	res, ok := fpaov.values.([]*Device_Spec_ProxyConfig)
	return res, ok
}

type DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues struct {
	DeviceStatusProxyConfigStatus_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusProxyConfigStatus_FieldPathArrayOfValues = (*DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues) AsDefaultConfigPathArrayOfValues() (DeviceSpecProxyConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecProxyConfig_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues) AsActiveConfigPathArrayOfValues() (DeviceSpecProxyConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecProxyConfig_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusProxyConfigStatus_FieldSubPathArrayOfValues) AsApiConfigPathArrayOfValues() (DeviceSpecProxyConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceSpecProxyConfig_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusDeviceInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfo_FieldPathSelectorArchitecture              DeviceStatusDeviceInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfo_FieldPathSelectorHardware                  DeviceStatusDeviceInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem           DeviceStatusDeviceInfo_FieldPathSelector = 2
	DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion             DeviceStatusDeviceInfo_FieldPathSelector = 3
	DeviceStatusDeviceInfo_FieldPathSelectorOsImage                   DeviceStatusDeviceInfo_FieldPathSelector = 4
	DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion   DeviceStatusDeviceInfo_FieldPathSelector = 5
	DeviceStatusDeviceInfo_FieldPathSelectorOsVersion                 DeviceStatusDeviceInfo_FieldPathSelector = 6
	DeviceStatusDeviceInfo_FieldPathSelectorDriver                    DeviceStatusDeviceInfo_FieldPathSelector = 7
	DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation       DeviceStatusDeviceInfo_FieldPathSelector = 8
	DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces         DeviceStatusDeviceInfo_FieldPathSelector = 9
	DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo DeviceStatusDeviceInfo_FieldPathSelector = 10
)

func (s DeviceStatusDeviceInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		return "architecture"
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		return "hardware"
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		return "operating_system"
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		return "kernel_version"
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		return "os_image"
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		return "container_runtime_version"
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		return "os_version"
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		return "driver"
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return "hardware_information"
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return "network_interfaces"
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return "control_plane_interface_info"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "architecture":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorArchitecture}, nil
		case "hardware":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorHardware}, nil
		case "operating_system", "operatingSystem", "operating-system":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem}, nil
		case "kernel_version", "kernelVersion", "kernel-version":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion}, nil
		case "os_image", "osImage", "os-image":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorOsImage}, nil
		case "container_runtime_version", "containerRuntimeVersion", "container-runtime-version":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion}, nil
		case "os_version", "osVersion", "os-version":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorOsVersion}, nil
		case "driver":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorDriver}, nil
		case "hardware_information", "hardwareInformation", "hardware-information":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation}, nil
		case "network_interfaces", "networkInterfaces", "network-interfaces":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces}, nil
		case "control_plane_interface_info", "controlPlaneInterfaceInfo", "control-plane-interface-info":
			return &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo}, nil
		}
	} else {
		switch fp[0] {
		case "hardware_information", "hardwareInformation", "hardware-information":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfo_FieldSubPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation, subPath: subpath}, nil
			}
		case "control_plane_interface_info", "controlPlaneInterfaceInfo", "control-plane-interface-info":
			if subpath, err := BuildDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfo_FieldSubPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo, subPath: subpath}, nil
			}
		case "network_interfaces", "networkInterfaces", "network-interfaces":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Device_Status_DeviceInfo)", fp)
			}
			return &DeviceStatusDeviceInfo_FieldPathMap{selector: DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo", fp)
}

func ParseDeviceStatusDeviceInfo_FieldPath(rawField string) (DeviceStatusDeviceInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfo_FieldPath(rawField string) DeviceStatusDeviceInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfo_FieldPath = (*DeviceStatusDeviceInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo
func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
			values = append(values, source.Architecture)
		case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
			values = append(values, source.Hardware)
		case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
			values = append(values, source.OperatingSystem)
		case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
			values = append(values, source.KernelVersion)
		case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
			values = append(values, source.OsImage)
		case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
			values = append(values, source.ContainerRuntimeVersion)
		case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
			values = append(values, source.OsVersion)
		case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
			values = append(values, source.Driver)
		case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
			if source.HardwareInformation != nil {
				values = append(values, source.HardwareInformation)
			}
		case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
			if source.NetworkInterfaces != nil {
				values = append(values, source.NetworkInterfaces)
			}
		case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
			if source.ControlPlaneInterfaceInfo != nil {
				values = append(values, source.ControlPlaneInterfaceInfo)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo
func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		return source.GetArchitecture(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		return source.GetHardware(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		return source.GetOperatingSystem(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		return source.GetKernelVersion(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		return source.GetOsImage(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		return source.GetContainerRuntimeVersion(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		return source.GetOsVersion(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		return source.GetDriver(), source != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		res := source.GetHardwareInformation()
		return res, res != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		res := source.GetNetworkInterfaces()
		return res, res != nil
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		res := source.GetControlPlaneInterfaceInfo()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		return ""
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return (*Device_Status_DeviceInfo_HardwareInformation)(nil)
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return (map[string]*Device_Status_DeviceInfo_NetworkInterface)(nil)
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return (*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
			item.Architecture = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
			item.Hardware = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
			item.OperatingSystem = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
			item.KernelVersion = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
			item.OsImage = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
			item.ContainerRuntimeVersion = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
			item.OsVersion = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
			item.Driver = ""
		case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
			item.HardwareInformation = nil
		case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
			item.NetworkInterfaces = nil
		case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
			item.ControlPlaneInterfaceInfo = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorArchitecture ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorHardware ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorOsImage ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorOsVersion ||
		fp.selector == DeviceStatusDeviceInfo_FieldPathSelectorDriver
}

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

func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation)}
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(map[string]*Device_Status_DeviceInfo_NetworkInterface)}
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return &DeviceStatusDeviceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation)}
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]map[string]*Device_Status_DeviceInfo_NetworkInterface)}
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return &DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfo_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type DeviceStatusDeviceInfo_FieldPathMap struct {
	key      string
	selector DeviceStatusDeviceInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfo_FieldPath = (*DeviceStatusDeviceInfo_FieldPathMap)(nil)

func (fpm *DeviceStatusDeviceInfo_FieldPathMap) Selector() DeviceStatusDeviceInfo_FieldPathSelector {
	return fpm.selector
}

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

// String returns path representation in proto convention
func (fpm *DeviceStatusDeviceInfo_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 *DeviceStatusDeviceInfo_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

// Get returns all values pointed by selected field map key from source Device_Status_DeviceInfo
func (fpm *DeviceStatusDeviceInfo_FieldPathMap) Get(source *Device_Status_DeviceInfo) (values []interface{}) {
	switch fpm.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		if value, ok := source.GetNetworkInterfaces()[fpm.key]; ok {
			values = append(values, value)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
	}
	return
}

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

// GetSingle returns value by selected field map key from source Device_Status_DeviceInfo
func (fpm *DeviceStatusDeviceInfo_FieldPathMap) GetSingle(source *Device_Status_DeviceInfo) (interface{}, bool) {
	switch fpm.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		res, ok := source.GetNetworkInterfaces()[fpm.key]
		return res, ok
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fpm *DeviceStatusDeviceInfo_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		var v *Device_Status_DeviceInfo_NetworkInterface
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfo_FieldPathMap) ClearValue(item *Device_Status_DeviceInfo) {
	if item != nil {
		switch fpm.selector {
		case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
			delete(item.NetworkInterfaces, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
		}
	}
}

func (fpm *DeviceStatusDeviceInfo_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Device_Status_DeviceInfo))
}

// IsLeaf - whether field path is holds simple value
func (fpm *DeviceStatusDeviceInfo_FieldPathMap) IsLeaf() bool {
	switch fpm.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
	}
}

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

func (fpm *DeviceStatusDeviceInfo_FieldPathMap) WithIValue(value interface{}) DeviceStatusDeviceInfo_FieldPathValue {
	switch fpm.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return &DeviceStatusDeviceInfo_FieldPathMapValue{DeviceStatusDeviceInfo_FieldPathMap: *fpm, value: value.(*Device_Status_DeviceInfo_NetworkInterface)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
	}
}

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

func (fpm *DeviceStatusDeviceInfo_FieldPathMap) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfo_FieldPathArrayOfValues {
	switch fpm.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return &DeviceStatusDeviceInfo_FieldPathMapArrayOfValues{DeviceStatusDeviceInfo_FieldPathMap: *fpm, values: values.([]*Device_Status_DeviceInfo_NetworkInterface)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpm.selector))
	}
}

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

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

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

type DeviceStatusDeviceInfo_FieldSubPath struct {
	selector DeviceStatusDeviceInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfo_FieldPath = (*DeviceStatusDeviceInfo_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfo_FieldSubPath) Selector() DeviceStatusDeviceInfo_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfo_FieldSubPath) AsHardwareInformationSubPath() (DeviceStatusDeviceInfoHardwareInformation_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformation_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfo_FieldSubPath) AsControlPlaneInterfaceInfoSubPath() (DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *DeviceStatusDeviceInfo_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
			fps.subPath.ClearValueRaw(item.HardwareInformation)
		case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
			fps.subPath.ClearValueRaw(item.ControlPlaneInterfaceInfo)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo))
}

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

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

func (fps *DeviceStatusDeviceInfo_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfo_FieldPathValue {
	return &DeviceStatusDeviceInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatusDeviceInfo_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfo_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatusDeviceInfo_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfo_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceStatusDeviceInfo_FieldPathValue allows storing values for DeviceInfo fields according to their type
type DeviceStatusDeviceInfo_FieldPathValue interface {
	DeviceStatusDeviceInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo)
	CompareWith(*Device_Status_DeviceInfo) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfo_FieldPathValue = (*DeviceStatusDeviceInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeviceInfo' as interface{}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsArchitectureValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsHardwareValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsOperatingSystemValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsKernelVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsOsImageValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsContainerRuntimeVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsOsVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsDriverValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsHardwareInformationValue() (*Device_Status_DeviceInfo_HardwareInformation, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsNetworkInterfacesValue() (map[string]*Device_Status_DeviceInfo_NetworkInterface, bool) {
	res, ok := fpv.value.(map[string]*Device_Status_DeviceInfo_NetworkInterface)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) AsControlPlaneInterfaceInfoValue() (*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)
	return res, ok
}

// SetTo stores value for selected field for object DeviceInfo
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		(*target).Architecture = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		(*target).Hardware = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		(*target).OperatingSystem = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		(*target).KernelVersion = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		(*target).OsImage = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		(*target).ContainerRuntimeVersion = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		(*target).OsVersion = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		(*target).Driver = fpv.value.(string)
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		(*target).HardwareInformation = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation)
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		(*target).NetworkInterfaces = fpv.value.(map[string]*Device_Status_DeviceInfo_NetworkInterface)
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		(*target).ControlPlaneInterfaceInfo = fpv.value.(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo'.
func (fpv *DeviceStatusDeviceInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		leftValue := fpv.value.(string)
		rightValue := source.GetArchitecture()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		leftValue := fpv.value.(string)
		rightValue := source.GetHardware()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatingSystem()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetKernelVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		leftValue := fpv.value.(string)
		rightValue := source.GetOsImage()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetContainerRuntimeVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetOsVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		leftValue := fpv.value.(string)
		rightValue := source.GetDriver()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return 0, false
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		return 0, false
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpv.selector))
	}
}

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

type DeviceStatusDeviceInfo_FieldPathMapValue struct {
	DeviceStatusDeviceInfo_FieldPathMap
	value interface{}
}

var _ DeviceStatusDeviceInfo_FieldPathValue = (*DeviceStatusDeviceInfo_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in DeviceInfo as interface{}
func (fpmv *DeviceStatusDeviceInfo_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *DeviceStatusDeviceInfo_FieldPathMapValue) AsNetworkInterfacesElementValue() (*Device_Status_DeviceInfo_NetworkInterface, bool) {
	res, ok := fpmv.value.(*Device_Status_DeviceInfo_NetworkInterface)
	return res, ok
}

// SetTo stores value for selected field in DeviceInfo
func (fpmv *DeviceStatusDeviceInfo_FieldPathMapValue) SetTo(target **Device_Status_DeviceInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo)
	}
	switch fpmv.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		if (*target).NetworkInterfaces == nil {
			(*target).NetworkInterfaces = make(map[string]*Device_Status_DeviceInfo_NetworkInterface)
		}
		(*target).NetworkInterfaces[fpmv.key] = fpmv.value.(*Device_Status_DeviceInfo_NetworkInterface)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpmv.selector))
	}
}

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

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

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

type DeviceStatusDeviceInfo_FieldSubPathValue struct {
	DeviceStatusDeviceInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfo_FieldPathValue = (*DeviceStatusDeviceInfo_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfo_FieldSubPathValue) AsHardwareInformationPathValue() (DeviceStatusDeviceInfoHardwareInformation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformation_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfo_FieldSubPathValue) AsControlPlaneInterfaceInfoPathValue() (DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfo_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformation_FieldPathValue).SetTo(&(*target).HardwareInformation)
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		fpvs.subPathValue.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue).SetTo(&(*target).ControlPlaneInterfaceInfo)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceStatusDeviceInfo_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformation_FieldPathValue).CompareWith(source.GetHardwareInformation())
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue).CompareWith(source.GetControlPlaneInterfaceInfo())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusDeviceInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'DeviceInfo'
func (fpaiv *DeviceStatusDeviceInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfo_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 DeviceStatusDeviceInfo_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfo_FieldSubPathArrayItemValue) AsHardwareInformationPathItemValue() (DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfo_FieldSubPathArrayItemValue) AsControlPlaneInterfaceInfoPathItemValue() (DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'DeviceInfo'
func (fpaivs *DeviceStatusDeviceInfo_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue).ContainsValue(source.GetHardwareInformation())
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue).ContainsValue(source.GetControlPlaneInterfaceInfo())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfo_FieldPathArrayOfValues allows storing slice of values for DeviceInfo fields according to their type
type DeviceStatusDeviceInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfo_FieldPath
}

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

func MustParseDeviceStatusDeviceInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorArchitecture:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardware:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsImage:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorOsVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorDriver:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		for _, v := range fpaov.values.([]map[string]*Device_Status_DeviceInfo_NetworkInterface) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsArchitectureArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsHardwareArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsOperatingSystemArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsKernelVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsOsImageArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsContainerRuntimeVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsOsVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsDriverArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsHardwareInformationArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsNetworkInterfacesArrayOfValues() ([]map[string]*Device_Status_DeviceInfo_NetworkInterface, bool) {
	res, ok := fpaov.values.([]map[string]*Device_Status_DeviceInfo_NetworkInterface)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfo_FieldTerminalPathArrayOfValues) AsControlPlaneInterfaceInfoArrayOfValues() ([]*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)
	return res, ok
}

type DeviceStatusDeviceInfo_FieldPathMapArrayOfValues struct {
	DeviceStatusDeviceInfo_FieldPathMap
	values interface{}
}

var _ DeviceStatusDeviceInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfo_FieldPathMapArrayOfValues)(nil)

func (fpmaov *DeviceStatusDeviceInfo_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces:
		for _, v := range fpmaov.values.([]*Device_Status_DeviceInfo_NetworkInterface) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *DeviceStatusDeviceInfo_FieldPathMapArrayOfValues) AsNetworkInterfacesArrayOfElementValues() ([]*Device_Status_DeviceInfo_NetworkInterface, bool) {
	res, ok := fpmaov.values.([]*Device_Status_DeviceInfo_NetworkInterface)
	return res, ok
}

type DeviceStatusDeviceInfo_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfo_FieldSubPathArrayOfValues) AsHardwareInformationPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfo_FieldSubPathArrayOfValues) AsControlPlaneInterfaceInfoPathArrayOfValues() (DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusNormalizedAddress_FieldPathSelector int32

const (
	DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode   DeviceStatusNormalizedAddress_FieldPathSelector = 0
	DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode  DeviceStatusNormalizedAddress_FieldPathSelector = 1
	DeviceStatusNormalizedAddress_FieldPathSelectorContinent    DeviceStatusNormalizedAddress_FieldPathSelector = 2
	DeviceStatusNormalizedAddress_FieldPathSelectorContinentId  DeviceStatusNormalizedAddress_FieldPathSelector = 3
	DeviceStatusNormalizedAddress_FieldPathSelectorCountry      DeviceStatusNormalizedAddress_FieldPathSelector = 4
	DeviceStatusNormalizedAddress_FieldPathSelectorCountryId    DeviceStatusNormalizedAddress_FieldPathSelector = 5
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1   DeviceStatusNormalizedAddress_FieldPathSelector = 6
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id DeviceStatusNormalizedAddress_FieldPathSelector = 7
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2   DeviceStatusNormalizedAddress_FieldPathSelector = 8
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id DeviceStatusNormalizedAddress_FieldPathSelector = 9
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3   DeviceStatusNormalizedAddress_FieldPathSelector = 10
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id DeviceStatusNormalizedAddress_FieldPathSelector = 11
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4   DeviceStatusNormalizedAddress_FieldPathSelector = 12
	DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id DeviceStatusNormalizedAddress_FieldPathSelector = 13
	DeviceStatusNormalizedAddress_FieldPathSelectorAddress      DeviceStatusNormalizedAddress_FieldPathSelector = 14
	DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates  DeviceStatusNormalizedAddress_FieldPathSelector = 15
	DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy     DeviceStatusNormalizedAddress_FieldPathSelector = 16
)

func (s DeviceStatusNormalizedAddress_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		return "postal_code"
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		return "country_code"
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		return "continent"
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		return "continent_id"
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		return "country"
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		return "country_id"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		return "admin_area1"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		return "admin_area1_id"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		return "admin_area2"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		return "admin_area2_id"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		return "admin_area3"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		return "admin_area3_id"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		return "admin_area4"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		return "admin_area4_id"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		return "address"
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		return "coordinates"
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		return "accuracy"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", s))
	}
}

func BuildDeviceStatusNormalizedAddress_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusNormalizedAddress_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_NormalizedAddress")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "postal_code", "postalCode", "postal-code":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode}, nil
		case "country_code", "countryCode", "country-code":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode}, nil
		case "continent":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorContinent}, nil
		case "continent_id", "continentId", "continent-id":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorContinentId}, nil
		case "country":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCountry}, nil
		case "country_id", "countryId", "country-id":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCountryId}, nil
		case "admin_area1", "adminArea1", "admin-area1":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1}, nil
		case "admin_area1_id", "adminArea1Id", "admin-area1-id":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id}, nil
		case "admin_area2", "adminArea2", "admin-area2":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2}, nil
		case "admin_area2_id", "adminArea2Id", "admin-area2-id":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id}, nil
		case "admin_area3", "adminArea3", "admin-area3":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3}, nil
		case "admin_area3_id", "adminArea3Id", "admin-area3-id":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id}, nil
		case "admin_area4", "adminArea4", "admin-area4":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4}, nil
		case "admin_area4_id", "adminArea4Id", "admin-area4-id":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id}, nil
		case "address":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAddress}, nil
		case "coordinates":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates}, nil
		case "accuracy":
			return &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_NormalizedAddress", fp)
}

func ParseDeviceStatusNormalizedAddress_FieldPath(rawField string) (DeviceStatusNormalizedAddress_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusNormalizedAddress_FieldPath(fp)
}

func MustParseDeviceStatusNormalizedAddress_FieldPath(rawField string) DeviceStatusNormalizedAddress_FieldPath {
	fp, err := ParseDeviceStatusNormalizedAddress_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusNormalizedAddress_FieldTerminalPath struct {
	selector DeviceStatusNormalizedAddress_FieldPathSelector
}

var _ DeviceStatusNormalizedAddress_FieldPath = (*DeviceStatusNormalizedAddress_FieldTerminalPath)(nil)

func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) Selector() DeviceStatusNormalizedAddress_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_NormalizedAddress
func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) Get(source *Device_Status_NormalizedAddress) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
			values = append(values, source.PostalCode)
		case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
			values = append(values, source.CountryCode)
		case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
			values = append(values, source.Continent)
		case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
			values = append(values, source.ContinentId)
		case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
			values = append(values, source.Country)
		case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
			values = append(values, source.CountryId)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
			values = append(values, source.AdminArea1)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
			values = append(values, source.AdminArea1Id)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
			values = append(values, source.AdminArea2)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
			values = append(values, source.AdminArea2Id)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
			values = append(values, source.AdminArea3)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
			values = append(values, source.AdminArea3Id)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
			values = append(values, source.AdminArea4)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
			values = append(values, source.AdminArea4Id)
		case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
			values = append(values, source.Address)
		case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
			if source.Coordinates != nil {
				values = append(values, source.Coordinates)
			}
		case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
			values = append(values, source.Accuracy)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_NormalizedAddress
func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) GetSingle(source *Device_Status_NormalizedAddress) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		return source.GetPostalCode(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		return source.GetCountryCode(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		return source.GetContinent(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		return source.GetContinentId(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		return source.GetCountry(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		return source.GetCountryId(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		return source.GetAdminArea1(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		return source.GetAdminArea1Id(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		return source.GetAdminArea2(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		return source.GetAdminArea2Id(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		return source.GetAdminArea3(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		return source.GetAdminArea3Id(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		return source.GetAdminArea4(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		return source.GetAdminArea4Id(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		return source.GetAddress(), source != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		res := source.GetCoordinates()
		return res, res != nil
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		return source.GetAccuracy(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		return ""
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		return (*latlng.LatLng)(nil)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		return float64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fp.selector))
	}
}

func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) ClearValue(item *Device_Status_NormalizedAddress) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
			item.PostalCode = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
			item.CountryCode = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
			item.Continent = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
			item.ContinentId = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
			item.Country = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
			item.CountryId = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
			item.AdminArea1 = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
			item.AdminArea1Id = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
			item.AdminArea2 = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
			item.AdminArea2Id = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
			item.AdminArea3 = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
			item.AdminArea3Id = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
			item.AdminArea4 = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
			item.AdminArea4Id = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
			item.Address = ""
		case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
			item.Coordinates = nil
		case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
			item.Accuracy = float64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_NormalizedAddress))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorContinent ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorContinentId ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorCountry ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorCountryId ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1 ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2 ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3 ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4 ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAddress ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates ||
		fp.selector == DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy
}

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

func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusNormalizedAddress_FieldPathValue {
	switch fp.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(*latlng.LatLng)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathValue{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusNormalizedAddress_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusNormalizedAddress_FieldPathArrayOfValues {
	fpaov := &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]*latlng.LatLng)}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		return &DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues{DeviceStatusNormalizedAddress_FieldTerminalPath: *fp, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusNormalizedAddress_FieldPathValue allows storing values for NormalizedAddress fields according to their type
type DeviceStatusNormalizedAddress_FieldPathValue interface {
	DeviceStatusNormalizedAddress_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_NormalizedAddress)
	CompareWith(*Device_Status_NormalizedAddress) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusNormalizedAddress_FieldPathValue(pathStr, valueStr string) DeviceStatusNormalizedAddress_FieldPathValue {
	fpv, err := ParseDeviceStatusNormalizedAddress_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusNormalizedAddress_FieldTerminalPathValue struct {
	DeviceStatusNormalizedAddress_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusNormalizedAddress_FieldPathValue = (*DeviceStatusNormalizedAddress_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NormalizedAddress' as interface{}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsPostalCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsCountryCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsContinentValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsContinentIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsCountryValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsCountryIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea1Value() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea1IdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea2Value() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea2IdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea3Value() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea3IdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea4Value() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAdminArea4IdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAddressValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsCoordinatesValue() (*latlng.LatLng, bool) {
	res, ok := fpv.value.(*latlng.LatLng)
	return res, ok
}
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) AsAccuracyValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field for object NormalizedAddress
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) SetTo(target **Device_Status_NormalizedAddress) {
	if *target == nil {
		*target = new(Device_Status_NormalizedAddress)
	}
	switch fpv.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		(*target).PostalCode = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		(*target).CountryCode = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		(*target).Continent = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		(*target).ContinentId = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		(*target).Country = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		(*target).CountryId = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		(*target).AdminArea1 = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		(*target).AdminArea1Id = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		(*target).AdminArea2 = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		(*target).AdminArea2Id = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		(*target).AdminArea3 = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		(*target).AdminArea3Id = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		(*target).AdminArea4 = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		(*target).AdminArea4Id = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		(*target).Address = fpv.value.(string)
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		(*target).Coordinates = fpv.value.(*latlng.LatLng)
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		(*target).Accuracy = fpv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusNormalizedAddress_FieldTerminalPathValue' with the value under path in 'Device_Status_NormalizedAddress'.
func (fpv *DeviceStatusNormalizedAddress_FieldTerminalPathValue) CompareWith(source *Device_Status_NormalizedAddress) (int, bool) {
	switch fpv.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetPostalCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetCountryCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		leftValue := fpv.value.(string)
		rightValue := source.GetContinent()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		leftValue := fpv.value.(string)
		rightValue := source.GetContinentId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		leftValue := fpv.value.(string)
		rightValue := source.GetCountry()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		leftValue := fpv.value.(string)
		rightValue := source.GetCountryId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea1()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea1Id()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea2()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea2Id()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea3()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea3Id()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea4()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		leftValue := fpv.value.(string)
		rightValue := source.GetAdminArea4Id()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		leftValue := fpv.value.(string)
		rightValue := source.GetAddress()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		return 0, false
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		leftValue := fpv.value.(float64)
		rightValue := source.GetAccuracy()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_NormalizedAddress: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusNormalizedAddress_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusNormalizedAddress_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusNormalizedAddress_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusNormalizedAddress_FieldTerminalPathArrayItemValue struct {
	DeviceStatusNormalizedAddress_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusNormalizedAddress_FieldPathArrayItemValue = (*DeviceStatusNormalizedAddress_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusNormalizedAddress_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_NormalizedAddress) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusNormalizedAddress_FieldPathArrayOfValues allows storing slice of values for NormalizedAddress fields according to their type
type DeviceStatusNormalizedAddress_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusNormalizedAddress_FieldPath
}

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

func MustParseDeviceStatusNormalizedAddress_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusNormalizedAddress_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusNormalizedAddress_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues struct {
	DeviceStatusNormalizedAddress_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusNormalizedAddress_FieldPathArrayOfValues = (*DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinent:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorContinentId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountry:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCountryId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAddress:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates:
		for _, v := range fpaov.values.([]*latlng.LatLng) {
			values = append(values, v)
		}
	case DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsPostalCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsCountryCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsContinentArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsContinentIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsCountryArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsCountryIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea1ArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea1IdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea2ArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea2IdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea3ArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea3IdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea4ArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAdminArea4IdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAddressArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsCoordinatesArrayOfValues() ([]*latlng.LatLng, bool) {
	res, ok := fpaov.values.([]*latlng.LatLng)
	return res, ok
}
func (fpaov *DeviceStatusNormalizedAddress_FieldTerminalPathArrayOfValues) AsAccuracyArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}

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

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

type DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs          DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios        DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem      DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu         DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock       DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork     DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu         DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo  DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 7
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo   DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 8
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo  DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 9
	DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector = 10
)

func (s DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return "os"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return "bios"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return "system"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return "cpu"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return "block"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return "network"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return "gpu"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return "memory_info"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return "hailo_info"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return "nvidia_info"
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return "modem_status"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformation_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformation_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "os":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs}, nil
		case "bios":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios}, nil
		case "system":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem}, nil
		case "cpu":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu}, nil
		case "block":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock}, nil
		case "network":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork}, nil
		case "gpu":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu}, nil
		case "memory_info", "memoryInfo", "memory-info":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo}, nil
		case "hailo_info", "hailoInfo", "hailo-info":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo}, nil
		case "nvidia_info", "nvidiaInfo", "nvidia-info":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo}, nil
		case "modem_status", "modemStatus", "modem-status":
			return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus}, nil
		}
	} else {
		switch fp[0] {
		case "os":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationOS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs, subPath: subpath}, nil
			}
		case "bios":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios, subPath: subpath}, nil
			}
		case "system":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationSystem_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem, subPath: subpath}, nil
			}
		case "cpu":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationCPU_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu, subPath: subpath}, nil
			}
		case "block":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationBlock_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock, subPath: subpath}, nil
			}
		case "network":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork, subPath: subpath}, nil
			}
		case "gpu":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationGPU_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu, subPath: subpath}, nil
			}
		case "memory_info", "memoryInfo", "memory-info":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo, subPath: subpath}, nil
			}
		case "hailo_info", "hailoInfo", "hailo-info":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo, subPath: subpath}, nil
			}
		case "nvidia_info", "nvidiaInfo", "nvidia-info":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo, subPath: subpath}, nil
			}
		case "modem_status", "modemStatus", "modem-status":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformation_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformation_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformation_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformation_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformation_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformation_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPath = (*DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation
func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
			if source.Os != nil {
				values = append(values, source.Os)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
			if source.Bios != nil {
				values = append(values, source.Bios)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
			if source.System != nil {
				values = append(values, source.System)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
			if source.Cpu != nil {
				values = append(values, source.Cpu)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
			if source.Block != nil {
				values = append(values, source.Block)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
			if source.Network != nil {
				values = append(values, source.Network)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
			if source.Gpu != nil {
				values = append(values, source.Gpu)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
			if source.MemoryInfo != nil {
				values = append(values, source.MemoryInfo)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
			if source.HailoInfo != nil {
				values = append(values, source.HailoInfo)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
			if source.NvidiaInfo != nil {
				values = append(values, source.NvidiaInfo)
			}
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
			for _, value := range source.GetModemStatus() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation
func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		res := source.GetOs()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		res := source.GetBios()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		res := source.GetSystem()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		res := source.GetCpu()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		res := source.GetBlock()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		res := source.GetNetwork()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		res := source.GetGpu()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		res := source.GetMemoryInfo()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		res := source.GetHailoInfo()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		res := source.GetNvidiaInfo()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		res := source.GetModemStatus()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return (*Device_Status_DeviceInfo_HardwareInformation_OS)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return (*Device_Status_DeviceInfo_HardwareInformation_BIOS)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return (*Device_Status_DeviceInfo_HardwareInformation_System)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return (*Device_Status_DeviceInfo_HardwareInformation_CPU)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return (*Device_Status_DeviceInfo_HardwareInformation_Block)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return (*Device_Status_DeviceInfo_HardwareInformation_Network)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return (*Device_Status_DeviceInfo_HardwareInformation_GPU)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return (*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return (*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return (*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)(nil)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
			item.Os = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
			item.Bios = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
			item.System = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
			item.Cpu = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
			item.Block = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
			item.Network = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
			item.Gpu = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
			item.MemoryInfo = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
			item.HailoInfo = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
			item.NvidiaInfo = nil
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
			item.ModemStatus = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation))
}

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

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

func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformation_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_OS)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_BIOS)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_System)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_CPU)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_Block)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_Network)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_GPU)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_OS)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_BIOS)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_System)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_CPU)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_Block)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_Network)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_GPU)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fp.selector))
	}
}

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

type DeviceStatusDeviceInfoHardwareInformation_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPath = (*DeviceStatusDeviceInfoHardwareInformation_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformation_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsOsSubPath() (DeviceStatusDeviceInfoHardwareInformationOS_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsBiosSubPath() (DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsSystemSubPath() (DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsCpuSubPath() (DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsBlockSubPath() (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsNetworkSubPath() (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsGpuSubPath() (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsMemoryInfoSubPath() (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsHailoInfoSubPath() (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsNvidiaInfoSubPath() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) AsModemStatusSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		values = append(values, fps.subPath.GetRaw(source.GetOs())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		values = append(values, fps.subPath.GetRaw(source.GetBios())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		values = append(values, fps.subPath.GetRaw(source.GetSystem())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		values = append(values, fps.subPath.GetRaw(source.GetCpu())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		values = append(values, fps.subPath.GetRaw(source.GetBlock())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		values = append(values, fps.subPath.GetRaw(source.GetNetwork())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		values = append(values, fps.subPath.GetRaw(source.GetGpu())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		values = append(values, fps.subPath.GetRaw(source.GetMemoryInfo())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		values = append(values, fps.subPath.GetRaw(source.GetHailoInfo())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		values = append(values, fps.subPath.GetRaw(source.GetNvidiaInfo())...)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		for _, item := range source.GetModemStatus() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation
func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		if source.GetOs() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetOs())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		if source.GetBios() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetBios())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		if source.GetSystem() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSystem())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		if source.GetCpu() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetCpu())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		if source.GetBlock() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetBlock())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		if source.GetNetwork() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNetwork())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		if source.GetGpu() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetGpu())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		if source.GetMemoryInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMemoryInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		if source.GetHailoInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetHailoInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		if source.GetNvidiaInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNvidiaInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		if len(source.GetModemStatus()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetModemStatus()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fps.selector))
	}
}

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

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

func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
			fps.subPath.ClearValueRaw(item.Os)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
			fps.subPath.ClearValueRaw(item.Bios)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
			fps.subPath.ClearValueRaw(item.System)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
			fps.subPath.ClearValueRaw(item.Cpu)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
			fps.subPath.ClearValueRaw(item.Block)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
			fps.subPath.ClearValueRaw(item.Network)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
			fps.subPath.ClearValueRaw(item.Gpu)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
			fps.subPath.ClearValueRaw(item.MemoryInfo)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
			fps.subPath.ClearValueRaw(item.HailoInfo)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
			fps.subPath.ClearValueRaw(item.NvidiaInfo)
		case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
			for _, subItem := range item.ModemStatus {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation))
}

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

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

func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformation_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatusDeviceInfoHardwareInformation_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceStatusDeviceInfoHardwareInformation_FieldPathValue allows storing values for HardwareInformation fields according to their type
type DeviceStatusDeviceInfoHardwareInformation_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformation_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformation_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformation_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformation_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'HardwareInformation' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsOsValue() (*Device_Status_DeviceInfo_HardwareInformation_OS, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_OS)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsBiosValue() (*Device_Status_DeviceInfo_HardwareInformation_BIOS, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_BIOS)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsSystemValue() (*Device_Status_DeviceInfo_HardwareInformation_System, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_System)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsCpuValue() (*Device_Status_DeviceInfo_HardwareInformation_CPU, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_CPU)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsBlockValue() (*Device_Status_DeviceInfo_HardwareInformation_Block, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_Block)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsNetworkValue() (*Device_Status_DeviceInfo_HardwareInformation_Network, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_Network)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsGpuValue() (*Device_Status_DeviceInfo_HardwareInformation_GPU, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_GPU)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsMemoryInfoValue() (*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsHailoInfoValue() (*Device_Status_DeviceInfo_HardwareInformation_HailoInfo, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsNvidiaInfoValue() (*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) AsModemStatusValue() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	return res, ok
}

// SetTo stores value for selected field for object HardwareInformation
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		(*target).Os = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_OS)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		(*target).Bios = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_BIOS)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		(*target).System = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_System)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		(*target).Cpu = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_CPU)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		(*target).Block = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_Block)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		(*target).Network = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_Network)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		(*target).Gpu = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_GPU)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		(*target).MemoryInfo = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		(*target).HailoInfo = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		(*target).NvidiaInfo = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		(*target).ModemStatus = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation'.
func (fpv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fpv.selector))
	}
}

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

type DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformation_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsOsPathValue() (DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsBiosPathValue() (DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsSystemPathValue() (DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsCpuPathValue() (DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsBlockPathValue() (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsNetworkPathValue() (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsGpuPathValue() (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsMemoryInfoPathValue() (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsHailoInfoPathValue() (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsNvidiaInfoPathValue() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) AsModemStatusPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue).SetTo(&(*target).Os)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue).SetTo(&(*target).Bios)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue).SetTo(&(*target).System)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue).SetTo(&(*target).Cpu)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue).SetTo(&(*target).Block)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue).SetTo(&(*target).Network)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue).SetTo(&(*target).Gpu)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue).SetTo(&(*target).MemoryInfo)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue).SetTo(&(*target).HailoInfo)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue).SetTo(&(*target).NvidiaInfo)
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue).CompareWith(source.GetOs())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue).CompareWith(source.GetBios())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue).CompareWith(source.GetSystem())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue).CompareWith(source.GetCpu())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue).CompareWith(source.GetBlock())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue).CompareWith(source.GetNetwork())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue).CompareWith(source.GetGpu())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue).CompareWith(source.GetMemoryInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue).CompareWith(source.GetHailoInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue).CompareWith(source.GetNvidiaInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue) AsModemStatusItemValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'HardwareInformation'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformation_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 DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformation_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsOsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsBiosPathItemValue() (DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsSystemPathItemValue() (DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsCpuPathItemValue() (DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsBlockPathItemValue() (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsNetworkPathItemValue() (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsGpuPathItemValue() (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsMemoryInfoPathItemValue() (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsHailoInfoPathItemValue() (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsNvidiaInfoPathItemValue() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) AsModemStatusPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'HardwareInformation'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue).ContainsValue(source.GetOs())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue).ContainsValue(source.GetBios())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue).ContainsValue(source.GetSystem())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue).ContainsValue(source.GetCpu())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue).ContainsValue(source.GetBlock())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue).ContainsValue(source.GetNetwork())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue).ContainsValue(source.GetGpu())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue).ContainsValue(source.GetMemoryInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue).ContainsValue(source.GetHailoInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue).ContainsValue(source.GetNvidiaInfo())
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues allows storing slice of values for HardwareInformation fields according to their type
type DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformation_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_OS) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_BIOS) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_System) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_CPU) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_Block) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_Network) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_GPU) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsOsArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_OS, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_OS)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsBiosArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_BIOS, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_BIOS)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsSystemArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_System, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_System)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsCpuArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_CPU, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_CPU)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsBlockArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_Block, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_Block)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsNetworkArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_Network, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_Network)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsGpuArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_GPU, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_GPU)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsMemoryInfoArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsHailoInfoArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsNvidiaInfoArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPathArrayOfValues) AsModemStatusArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformation_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformation_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsOsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsBiosPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsSystemPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsCpuPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsBlockPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsNetworkPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsGpuPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsMemoryInfoPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsHailoInfoPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsNvidiaInfoPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformation_FieldSubPathArrayOfValues) AsModemStatusPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName       DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 0
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4         DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 1
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4 DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 2
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6         DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 3
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6 DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 4
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo              DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 5
	DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier             DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector = 6
)

func (s DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		return "interface_name"
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		return "ip_address_v4"
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		return "external_ip_address_v4"
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		return "ip_address_v6"
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		return "external_ip_address_v6"
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return "as_info"
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return "carrier"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoNetworkInterface_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoNetworkInterface_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_NetworkInterface")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "interface_name", "interfaceName", "interface-name":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName}, nil
		case "ip_address_v4", "ipAddressV4", "ip-address-v4":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4}, nil
		case "external_ip_address_v4", "externalIpAddressV4", "external-ip-address-v4":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4}, nil
		case "ip_address_v6", "ipAddressV6", "ip-address-v6":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6}, nil
		case "external_ip_address_v6", "externalIpAddressV6", "external-ip-address-v6":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6}, nil
		case "as_info", "asInfo", "as-info":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo}, nil
		case "carrier":
			return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier}, nil
		}
	} else {
		switch fp[0] {
		case "as_info", "asInfo", "as-info":
			if subpath, err := BuildDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoNetworkInterface_FieldSubPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo, subPath: subpath}, nil
			}
		case "carrier":
			if subpath, err := BuildDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoNetworkInterface_FieldSubPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_NetworkInterface", fp)
}

func ParseDeviceStatusDeviceInfoNetworkInterface_FieldPath(rawField string) (DeviceStatusDeviceInfoNetworkInterface_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoNetworkInterface_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoNetworkInterface_FieldPath(rawField string) DeviceStatusDeviceInfoNetworkInterface_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterface_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPath = (*DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) Selector() DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_NetworkInterface
func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_NetworkInterface) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
			values = append(values, source.InterfaceName)
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
			for _, value := range source.GetIpAddressV4() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
			for _, value := range source.GetExternalIpAddressV4() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
			for _, value := range source.GetIpAddressV6() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
			for _, value := range source.GetExternalIpAddressV6() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
			if source.AsInfo != nil {
				values = append(values, source.AsInfo)
			}
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
			if source.Carrier != nil {
				values = append(values, source.Carrier)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_NetworkInterface
func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_NetworkInterface) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		return source.GetInterfaceName(), source != nil
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		res := source.GetIpAddressV4()
		return res, res != nil
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		res := source.GetExternalIpAddressV4()
		return res, res != nil
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		res := source.GetIpAddressV6()
		return res, res != nil
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		res := source.GetExternalIpAddressV6()
		return res, res != nil
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		res := source.GetAsInfo()
		return res, res != nil
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		res := source.GetCarrier()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		return ""
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return (*Device_Status_DeviceInfo_NetworkInterface_ASInfo)(nil)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return (*Device_Status_DeviceInfo_NetworkInterface_Carrier)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_NetworkInterface) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
			item.InterfaceName = ""
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
			item.IpAddressV4 = nil
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
			item.ExternalIpAddressV4 = nil
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
			item.IpAddressV6 = nil
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
			item.ExternalIpAddressV6 = nil
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
			item.AsInfo = nil
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
			item.Carrier = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_NetworkInterface))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4 ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4 ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6 ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6
}

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

func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoNetworkInterface_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_NetworkInterface_Carrier)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_NetworkInterface_ASInfo)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_NetworkInterface_Carrier)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		return &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fp.selector))
	}
}

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

type DeviceStatusDeviceInfoNetworkInterface_FieldSubPath struct {
	selector DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPath = (*DeviceStatusDeviceInfoNetworkInterface_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) Selector() DeviceStatusDeviceInfoNetworkInterface_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) AsAsInfoSubPath() (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) AsCarrierSubPath() (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_NetworkInterface) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
			fps.subPath.ClearValueRaw(item.AsInfo)
		case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
			fps.subPath.ClearValueRaw(item.Carrier)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_NetworkInterface))
}

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

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

func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoNetworkInterface_FieldPathValue {
	return &DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatusDeviceInfoNetworkInterface_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceStatusDeviceInfoNetworkInterface_FieldPathValue allows storing values for NetworkInterface fields according to their type
type DeviceStatusDeviceInfoNetworkInterface_FieldPathValue interface {
	DeviceStatusDeviceInfoNetworkInterface_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_NetworkInterface)
	CompareWith(*Device_Status_DeviceInfo_NetworkInterface) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoNetworkInterface_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoNetworkInterface_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoNetworkInterface_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPathValue = (*DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NetworkInterface' as interface{}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsInterfaceNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsIpAddressV4Value() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsExternalIpAddressV4Value() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsIpAddressV6Value() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsExternalIpAddressV6Value() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsAsInfoValue() (*Device_Status_DeviceInfo_NetworkInterface_ASInfo, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) AsCarrierValue() (*Device_Status_DeviceInfo_NetworkInterface_Carrier, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_NetworkInterface_Carrier)
	return res, ok
}

// SetTo stores value for selected field for object NetworkInterface
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_NetworkInterface) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_NetworkInterface)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		(*target).InterfaceName = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		(*target).IpAddressV4 = fpv.value.([]string)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		(*target).ExternalIpAddressV4 = fpv.value.([]string)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		(*target).IpAddressV6 = fpv.value.([]string)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		(*target).ExternalIpAddressV6 = fpv.value.([]string)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		(*target).AsInfo = fpv.value.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		(*target).Carrier = fpv.value.(*Device_Status_DeviceInfo_NetworkInterface_Carrier)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_NetworkInterface'.
func (fpv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_NetworkInterface) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		leftValue := fpv.value.(string)
		rightValue := source.GetInterfaceName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		return 0, false
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		return 0, false
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		return 0, false
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		return 0, false
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return 0, false
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fpv.selector))
	}
}

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

type DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue struct {
	DeviceStatusDeviceInfoNetworkInterface_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPathValue = (*DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue) AsAsInfoPathValue() (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue) AsCarrierPathValue() (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_NetworkInterface) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_NetworkInterface)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		fpvs.subPathValue.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue).SetTo(&(*target).AsInfo)
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		fpvs.subPathValue.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue).SetTo(&(*target).Carrier)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_NetworkInterface) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue).CompareWith(source.GetAsInfo())
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue).CompareWith(source.GetCarrier())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoNetworkInterface_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoNetworkInterface_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_NetworkInterface as interface{}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) AsIpAddressV4ItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) AsExternalIpAddressV4ItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) AsIpAddressV6ItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) AsExternalIpAddressV6ItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_NetworkInterface) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'NetworkInterface'
func (fpaiv *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_NetworkInterface) bool {
	slice := fpaiv.DeviceStatusDeviceInfoNetworkInterface_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 DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoNetworkInterface_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayItemValue) AsAsInfoPathItemValue() (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayItemValue) AsCarrierPathItemValue() (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'NetworkInterface'
func (fpaivs *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_NetworkInterface) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue).ContainsValue(source.GetAsInfo())
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue).ContainsValue(source.GetCarrier())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues allows storing slice of values for NetworkInterface fields according to their type
type DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoNetworkInterface_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_NetworkInterface_ASInfo) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_NetworkInterface_Carrier) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsInterfaceNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsIpAddressV4ArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsExternalIpAddressV4ArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsIpAddressV6ArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsExternalIpAddressV6ArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsAsInfoArrayOfValues() ([]*Device_Status_DeviceInfo_NetworkInterface_ASInfo, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_NetworkInterface_ASInfo)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPathArrayOfValues) AsCarrierArrayOfValues() ([]*Device_Status_DeviceInfo_NetworkInterface_Carrier, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_NetworkInterface_Carrier)
	return res, ok
}

type DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoNetworkInterface_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoNetworkInterface_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayOfValues) AsAsInfoPathArrayOfValues() (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoNetworkInterface_FieldSubPathArrayOfValues) AsCarrierPathArrayOfValues() (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy                   DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback                  DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector = 2
)

func (s DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		return "active_control_plane_interface"
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		return "uses_proxy"
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		return "is_fallback"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_ControlPlaneInterfaceInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "active_control_plane_interface", "activeControlPlaneInterface", "active-control-plane-interface":
			return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface}, nil
		case "uses_proxy", "usesProxy", "uses-proxy":
			return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy}, nil
		case "is_fallback", "isFallback", "is-fallback":
			return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_ControlPlaneInterfaceInfo", fp)
}

func ParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath(rawField string) DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath = (*DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_ControlPlaneInterfaceInfo
func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
			values = append(values, source.ActiveControlPlaneInterface)
		case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
			values = append(values, source.UsesProxy)
		case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
			values = append(values, source.IsFallback)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_ControlPlaneInterfaceInfo
func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		return source.GetActiveControlPlaneInterface(), source != nil
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		return source.GetUsesProxy(), source != nil
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		return source.GetIsFallback(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		return ""
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		return false
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
			item.ActiveControlPlaneInterface = ""
		case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
			item.UsesProxy = false
		case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
			item.IsFallback = false
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface ||
		fp.selector == DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy ||
		fp.selector == DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback
}

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

func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		return &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue allows storing values for ControlPlaneInterfaceInfo fields according to their type
type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)
	CompareWith(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathValue = (*DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ControlPlaneInterfaceInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue) AsActiveControlPlaneInterfaceValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue) AsUsesProxyValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue) AsIsFallbackValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object ControlPlaneInterfaceInfo
func (fpv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		(*target).ActiveControlPlaneInterface = fpv.value.(string)
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		(*target).UsesProxy = fpv.value.(bool)
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		(*target).IsFallback = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_ControlPlaneInterfaceInfo'.
func (fpv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		leftValue := fpv.value.(string)
		rightValue := source.GetActiveControlPlaneInterface()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		leftValue := fpv.value.(bool)
		rightValue := source.GetUsesProxy()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsFallback()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_ControlPlaneInterfaceInfo: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues allows storing slice of values for ControlPlaneInterfaceInfo fields according to their type
type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues) AsActiveControlPlaneInterfaceArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues) AsUsesProxyArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPathArrayOfValues) AsIsFallbackArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

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

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

type DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName        DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription:
		return "description"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Capability: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationCapability_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_Capability")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName}, nil
		case "description":
			return &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_Capability", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationCapability_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Capability) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription:
			item.Description = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Capability: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Capability))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Capability: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Capability: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue allows storing values for Capability fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Capability)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_Capability) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Capability
func (fpv *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Capability) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Capability)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Capability: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Capability'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Capability) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCapability_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
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Capability: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Capability) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues allows storing slice of values for Capability fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationOS_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_OS) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_OS) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_OS)

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

type DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem         DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion           DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage                 DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector = 3
)

func (s DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		return "operating_system"
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		return "kernel_version"
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		return "os_image"
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		return "container_runtime_version"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationOS_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationOS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_OS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "operating_system", "operatingSystem", "operating-system":
			return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem}, nil
		case "kernel_version", "kernelVersion", "kernel-version":
			return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion}, nil
		case "os_image", "osImage", "os-image":
			return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage}, nil
		case "container_runtime_version", "containerRuntimeVersion", "container-runtime-version":
			return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_OS", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationOS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationOS_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationOS_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationOS_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_OS
func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_OS) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
			values = append(values, source.OperatingSystem)
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
			values = append(values, source.KernelVersion)
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
			values = append(values, source.OsImage)
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
			values = append(values, source.ContainerRuntimeVersion)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_OS
func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_OS) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		return source.GetOperatingSystem(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		return source.GetKernelVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		return source.GetOsImage(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		return source.GetContainerRuntimeVersion(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_OS) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
			item.OperatingSystem = ""
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
			item.KernelVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
			item.OsImage = ""
		case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
			item.ContainerRuntimeVersion = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_OS))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		return &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue allows storing values for OS fields according to their type
type DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationOS_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_OS)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_OS) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationOS_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'OS' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) AsOperatingSystemValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) AsKernelVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) AsOsImageValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) AsContainerRuntimeVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object OS
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_OS) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_OS)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		(*target).OperatingSystem = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		(*target).KernelVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		(*target).OsImage = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		(*target).ContainerRuntimeVersion = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_OS'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_OS) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatingSystem()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetKernelVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		leftValue := fpv.value.(string)
		rightValue := source.GetOsImage()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetContainerRuntimeVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_OS: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_OS) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues allows storing slice of values for OS fields according to their type
type DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationOS_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationOS_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues) AsOperatingSystemArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues) AsKernelVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues) AsOsImageArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPathArrayOfValues) AsContainerRuntimeVersionArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_BIOS)

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

type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor      DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector = 2
)

func (s DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		return "vendor"
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		return "bios_version"
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		return "release_date"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_BIOS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "vendor":
			return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor}, nil
		case "bios_version", "biosVersion", "bios-version":
			return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion}, nil
		case "release_date", "releaseDate", "release-date":
			return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_BIOS", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_BIOS
func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
			values = append(values, source.Vendor)
		case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
			values = append(values, source.BiosVersion)
		case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
			values = append(values, source.ReleaseDate)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_BIOS
func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		return source.GetVendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		return source.GetBiosVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		return source.GetReleaseDate(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fp.selector))
	}
}

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

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

func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_BIOS) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
			item.Vendor = ""
		case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
			item.BiosVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
			item.ReleaseDate = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_BIOS))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		return &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue allows storing values for BIOS fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_BIOS)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_BIOS) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BIOS' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue) AsVendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue) AsBiosVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue) AsReleaseDateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object BIOS
func (fpv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_BIOS) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_BIOS)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		(*target).Vendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		(*target).BiosVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		(*target).ReleaseDate = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_BIOS'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetVendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetBiosVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		leftValue := fpv.value.(string)
		rightValue := source.GetReleaseDate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_BIOS: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) (interface{}, bool) {
	return nil, false
}

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

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

// DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues allows storing slice of values for BIOS fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues) AsVendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues) AsBiosVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPathArrayOfValues) AsReleaseDateArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_System) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_System) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_System)

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

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer  DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName   DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion       DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber  DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector = 4
)

func (s DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		return "manufacturer"
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		return "product_name"
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		return "version"
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		return "serial_number"
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return "configuration"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationSystem_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_System")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "manufacturer":
			return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer}, nil
		case "product_name", "productName", "product-name":
			return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName}, nil
		case "version":
			return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion}, nil
		case "serial_number", "serialNumber", "serial-number":
			return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber}, nil
		case "configuration":
			return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration}, nil
		}
	} else {
		switch fp[0] {
		case "configuration":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_System", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationSystem_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_System
func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_System) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
			values = append(values, source.Manufacturer)
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
			values = append(values, source.ProductName)
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
			values = append(values, source.Version)
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
			values = append(values, source.SerialNumber)
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
			if source.Configuration != nil {
				values = append(values, source.Configuration)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_System
func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_System) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		return source.GetManufacturer(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		return source.GetProductName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		return source.GetVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		return source.GetSerialNumber(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		res := source.GetConfiguration()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return (*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_System) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
			item.Manufacturer = ""
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
			item.ProductName = ""
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
			item.Version = ""
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
			item.SerialNumber = ""
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
			item.Configuration = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_System))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) AsConfigurationSubPath() (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_System) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
			fps.subPath.ClearValueRaw(item.Configuration)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_System))
}

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

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

func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue allows storing values for System fields according to their type
type DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_System)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_System) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'System' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) AsManufacturerValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) AsProductNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) AsVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) AsSerialNumberValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) AsConfigurationValue() (*Device_Status_DeviceInfo_HardwareInformation_System_Configuration, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
	return res, ok
}

// SetTo stores value for selected field for object System
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_System) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_System)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		(*target).Manufacturer = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		(*target).ProductName = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		(*target).Version = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		(*target).SerialNumber = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		(*target).Configuration = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_System'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_System) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		leftValue := fpv.value.(string)
		rightValue := source.GetManufacturer()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		leftValue := fpv.value.(string)
		rightValue := source.GetProductName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		leftValue := fpv.value.(string)
		rightValue := source.GetSerialNumber()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fpv.selector))
	}
}

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

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathValue) AsConfigurationPathValue() (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_System) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_System)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue).SetTo(&(*target).Configuration)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_System) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue).CompareWith(source.GetConfiguration())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_System) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'System'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_System) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationSystem_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 DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'System'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_System) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue).ContainsValue(source.GetConfiguration())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues allows storing slice of values for System fields according to their type
type DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_System_Configuration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues) AsManufacturerArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues) AsProductNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues) AsVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues) AsSerialNumberArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPathArrayOfValues) AsConfigurationArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_System_Configuration, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationSystem_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPathArrayOfValues) AsConfigurationPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector = 0
)

func (s DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
		return "processors"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationCPU_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_CPU")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "processors":
			return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors}, nil
		}
	} else {
		switch fp[0] {
		case "processors":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_CPU", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationCPU_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_CPU) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
			item.Processors = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_CPU))
}

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

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
		return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU: %d", fp.selector))
	}
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
		return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
		return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU: %d", fp.selector))
	}
}

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

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath) AsProcessorsSubPath() (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_CPU))
}

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

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

func (fps *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue allows storing values for CPU fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_CPU) (cmp int, comparable bool)
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CPU' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathValue) AsProcessorsValue() ([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	return res, ok
}

// SetTo stores value for selected field for object CPU
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_CPU)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
		(*target).Processors = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU: %d", fpv.selector))
	}
}

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

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

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

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathValue) AsProcessorsPathValue() (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_CPU as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue) AsProcessorsItemValue() (*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CPU'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_CPU) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationCPU_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 DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues allows storing slice of values for CPU fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath
}

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

func MustParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPathArrayOfValues) AsProcessorsArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationCPU_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationCPU_FieldSubPathArrayOfValues) AsProcessorsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector = 0
)

func (s DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return "disks"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationBlock_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_Block")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "disks":
			return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks}, nil
		}
	} else {
		switch fp[0] {
		case "disks":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_Block", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationBlock_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
			item.Disks = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) AsDisksSubPath() (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_Block
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Block) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		for _, item := range source.GetDisks() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_Block
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		if len(source.GetDisks()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDisks()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
			for _, subItem := range item.Disks {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue allows storing values for Block fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_Block) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_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 Block field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Block' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue) AsDisksValue() ([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	return res, ok
}

// SetTo stores value for selected field for object Block
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Block)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		(*target).Disks = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Block)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Block'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Block) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue) AsDisksPathValue() (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Block)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Block)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Block) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

// DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue allows storing single item in Path-specific values for Block according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_Block) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_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 Block field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_Block as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue) AsDisksItemValue() (*Device_Status_DeviceInfo_HardwareInformation_Block_Disk, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Block'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Block) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationBlock_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 DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayItemValue) AsDisksPathItemValue() (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Block'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Block) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues allows storing slice of values for Block fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_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 Block field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPathArrayOfValues) AsDisksArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationBlock_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationBlock_FieldSubPathArrayOfValues) AsDisksPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_Network) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Network)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector = 0
)

func (s DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return "nics"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_Network")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "nics":
			return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics}, nil
		}
	} else {
		switch fp[0] {
		case "nics":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_Network", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_Network
func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Network) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
			for _, value := range source.GetNics() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_Network
func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		res := source.GetNics()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Network) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
			item.Nics = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) AsNicsSubPath() (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_Network
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Network) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		for _, item := range source.GetNics() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_Network
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		if len(source.GetNics()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNics()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Network) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
			for _, subItem := range item.Nics {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue allows storing values for Network fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Network)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_Network) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_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 Network field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Network' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue) AsNicsValue() ([]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	return res, ok
}

// SetTo stores value for selected field for object Network
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Network) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Network)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		(*target).Nics = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Network)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Network'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Network) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue) AsNicsPathValue() (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Network) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Network)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Network)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Network) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue allows storing single item in Path-specific values for Network according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_Network) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_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 Network field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_Network as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue) AsNicsItemValue() (*Device_Status_DeviceInfo_HardwareInformation_Network_NIC, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Network'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Network) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationNetwork_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 DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayItemValue) AsNicsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Network'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Network) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues allows storing slice of values for Network fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_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 Network field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPathArrayOfValues) AsNicsArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationNetwork_FieldSubPathArrayOfValues) AsNicsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_GPU) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_GPU)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector = 0
)

func (s DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return "graphic_cards"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationGPU_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_GPU")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "graphic_cards", "graphicCards", "graphic-cards":
			return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards}, nil
		}
	} else {
		switch fp[0] {
		case "graphic_cards", "graphicCards", "graphic-cards":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_GPU", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationGPU_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_GPU
func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
			for _, value := range source.GetGraphicCards() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_GPU
func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		res := source.GetGraphicCards()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_GPU) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
			item.GraphicCards = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) AsGraphicCardsSubPath() (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_GPU
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		for _, item := range source.GetGraphicCards() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_GPU
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		if len(source.GetGraphicCards()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetGraphicCards()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_GPU) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
			for _, subItem := range item.GraphicCards {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue allows storing values for GPU fields according to their type
type DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_GPU)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_GPU) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_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 GPU field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'GPU' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue) AsGraphicCardsValue() ([]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	return res, ok
}

// SetTo stores value for selected field for object GPU
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_GPU) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_GPU)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		(*target).GraphicCards = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_GPU)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_GPU'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue) AsGraphicCardsPathValue() (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_GPU) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_GPU)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_GPU)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue allows storing single item in Path-specific values for GPU according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_GPU) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_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 GPU field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_GPU as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue) AsGraphicCardsItemValue() (*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

// Contains returns a boolean indicating if value that is being held is present in given 'GPU'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_GPU) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationGPU_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 DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayItemValue) AsGraphicCardsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'GPU'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_GPU) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues allows storing slice of values for GPU fields according to their type
type DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_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 GPU field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPathArrayOfValues) AsGraphicCardsArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationGPU_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationGPU_FieldSubPathArrayOfValues) AsGraphicCardsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_PCIDevice)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress   DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor    DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct   DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName      DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector = 4
)

func (s DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		return "address"
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		return "vendor"
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		return "product"
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		return "subvendor"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_PCIDevice")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "address":
			return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress}, nil
		case "vendor":
			return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor}, nil
		case "product":
			return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct}, nil
		case "name":
			return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName}, nil
		case "subvendor":
			return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_PCIDevice", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_PCIDevice
func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
			values = append(values, source.Address)
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
			values = append(values, source.Vendor)
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
			values = append(values, source.Product)
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
			values = append(values, source.Subvendor)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_PCIDevice
func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		return source.GetAddress(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		return source.GetVendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		return source.GetProduct(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		return source.GetSubvendor(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
			item.Address = ""
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
			item.Vendor = ""
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
			item.Product = ""
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
			item.Subvendor = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		return &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue allows storing values for PCIDevice fields according to their type
type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_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 PCIDevice field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PCIDevice' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) AsAddressValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) AsVendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) AsProductValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) AsSubvendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object PCIDevice
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_PCIDevice) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		(*target).Address = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		(*target).Vendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		(*target).Product = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		(*target).Subvendor = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_PCIDevice'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		leftValue := fpv.value.(string)
		rightValue := source.GetAddress()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetVendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		leftValue := fpv.value.(string)
		rightValue := source.GetProduct()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetSubvendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_PCIDevice: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

// DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue allows storing single item in Path-specific values for PCIDevice according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_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 PCIDevice field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_PCIDevice as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

// Contains returns a boolean indicating if value that is being held is present in given 'PCIDevice'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationPCIDevice_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
}

// DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues allows storing slice of values for PCIDevice fields according to their type
type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_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 PCIDevice field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues) AsAddressArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues) AsVendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues) AsProductArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPathArrayOfValues) AsSubvendorArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes   DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector = 2
)

func (s DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		return "description"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		return "size_bytes"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return "memory_banks"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_MemoryInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription}, nil
		case "size_bytes", "sizeBytes", "size-bytes":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes}, nil
		case "memory_banks", "memoryBanks", "memory-banks":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks}, nil
		}
	} else {
		switch fp[0] {
		case "memory_banks", "memoryBanks", "memory-banks":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_MemoryInfo", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_MemoryInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
			values = append(values, source.SizeBytes)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
			for _, value := range source.GetMemoryBanks() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_MemoryInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		return source.GetSizeBytes(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		res := source.GetMemoryBanks()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
			item.Description = ""
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
			item.SizeBytes = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
			item.MemoryBanks = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) AsMemoryBanksSubPath() (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_MemoryInfo
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		for _, item := range source.GetMemoryBanks() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_MemoryInfo
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		if len(source.GetMemoryBanks()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMemoryBanks()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
			for _, subItem := range item.MemoryBanks {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue allows storing values for MemoryInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_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 MemoryInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'MemoryInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) AsSizeBytesValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) AsMemoryBanksValue() ([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	return res, ok
}

// SetTo stores value for selected field for object MemoryInfo
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		(*target).SizeBytes = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		(*target).MemoryBanks = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_MemoryInfo'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_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 DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSizeBytes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue) AsMemoryBanksPathValue() (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue allows storing single item in Path-specific values for MemoryInfo according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_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 MemoryInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_MemoryInfo as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue) AsMemoryBanksItemValue() (*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

// Contains returns a boolean indicating if value that is being held is present in given 'MemoryInfo'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationMemoryInfo_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 DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayItemValue) AsMemoryBanksPathItemValue() (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'MemoryInfo'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues allows storing slice of values for MemoryInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_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 MemoryInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues) AsSizeBytesArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPathArrayOfValues) AsMemoryBanksArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldSubPathArrayOfValues) AsMemoryBanksPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_HailoInfo)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus     DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules    DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector = 2
)

func (s DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		return "status"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		return "cli_version"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return "modules"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_HailoInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "status":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus}, nil
		case "cli_version", "cliVersion", "cli-version":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion}, nil
		case "modules":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules}, nil
		}
	} else {
		switch fp[0] {
		case "modules":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_HailoInfo", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_HailoInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
			values = append(values, source.Status)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
			values = append(values, source.CliVersion)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
			for _, value := range source.GetModules() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_HailoInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		return source.GetStatus(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		return source.GetCliVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		res := source.GetModules()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
			item.Status = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
			item.CliVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
			item.Modules = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) AsModulesSubPath() (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_HailoInfo
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		for _, item := range source.GetModules() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_HailoInfo
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		if len(source.GetModules()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetModules()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
			for _, subItem := range item.Modules {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue allows storing values for HailoInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_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 HailoInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'HailoInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) AsStatusValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) AsCliVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) AsModulesValue() ([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	return res, ok
}

// SetTo stores value for selected field for object HailoInfo
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_HailoInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		(*target).CliVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		(*target).Modules = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_HailoInfo'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		leftValue := fpv.value.(string)
		rightValue := source.GetStatus()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetCliVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue) AsModulesPathValue() (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_HailoInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue allows storing single item in Path-specific values for HailoInfo according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_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 HailoInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_HailoInfo as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue) AsModulesItemValue() (*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

// Contains returns a boolean indicating if value that is being held is present in given 'HailoInfo'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationHailoInfo_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 DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayItemValue) AsModulesPathItemValue() (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'HailoInfo'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues allows storing slice of values for HailoInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_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 HailoInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues) AsCliVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPathArrayOfValues) AsModulesArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldSubPathArrayOfValues) AsModulesPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus        DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion   DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus          DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector = 3
)

func (s DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		return "status"
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		return "driver_version"
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		return "cuda_version"
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return "gpus"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "status":
			return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus}, nil
		case "driver_version", "driverVersion", "driver-version":
			return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion}, nil
		case "cuda_version", "cudaVersion", "cuda-version":
			return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion}, nil
		case "gpus":
			return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus}, nil
		}
	} else {
		switch fp[0] {
		case "gpus":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
			values = append(values, source.Status)
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
			values = append(values, source.DriverVersion)
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
			values = append(values, source.CudaVersion)
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
			for _, value := range source.GetGpus() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		return source.GetStatus(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		return source.GetDriverVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		return source.GetCudaVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		res := source.GetGpus()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
			item.Status = ""
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
			item.DriverVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
			item.CudaVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
			item.Gpus = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) AsGpusSubPath() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		for _, item := range source.GetGpus() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		if len(source.GetGpus()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetGpus()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
			for _, subItem := range item.Gpus {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue allows storing values for NvidiaInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_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 NvidiaInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NvidiaInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) AsStatusValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) AsDriverVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) AsCudaVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) AsGpusValue() ([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	return res, ok
}

// SetTo stores value for selected field for object NvidiaInfo
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		(*target).DriverVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		(*target).CudaVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		(*target).Gpus = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		leftValue := fpv.value.(string)
		rightValue := source.GetStatus()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetDriverVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetCudaVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue) AsGpusPathValue() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue allows storing single item in Path-specific values for NvidiaInfo according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_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 NvidiaInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue) AsGpusItemValue() (*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

// Contains returns a boolean indicating if value that is being held is present in given 'NvidiaInfo'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_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 DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayItemValue) AsGpusPathItemValue() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'NvidiaInfo'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues allows storing slice of values for NvidiaInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_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 NvidiaInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues) AsDriverVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues) AsCudaVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPathArrayOfValues) AsGpusArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldSubPathArrayOfValues) AsGpusPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector = 0
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return "modem"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "modem":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem}, nil
		}
	} else {
		switch fp[0] {
		case "modem":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
			if source.Modem != nil {
				values = append(values, source.Modem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		res := source.GetModem()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
			item.Modem = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) AsModemSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		values = append(values, fps.subPath.GetRaw(source.GetModem())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		if source.GetModem() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetModem())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
			fps.subPath.ClearValueRaw(item.Modem)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue allows storing values for ModemStatus fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_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 ModemStatus field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ModemStatus' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue) AsModemValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	return res, ok
}

// SetTo stores value for selected field for object ModemStatus
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		(*target).Modem = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue) AsModemPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue).SetTo(&(*target).Modem)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue).CompareWith(source.GetModem())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue allows storing single item in Path-specific values for ModemStatus according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_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 ModemStatus field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ModemStatus'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatus_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 DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayItemValue) AsModemPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ModemStatus'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue).ContainsValue(source.GetModem())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues allows storing slice of values for ModemStatus fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_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 ModemStatus field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPathArrayOfValues) AsModemArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPathArrayOfValues) AsModemPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_System_Configuration)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis   DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid      DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily    DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector = 3
)

func (s DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		return "chassis"
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		return "uuid"
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		return "sku_number"
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		return "family"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_System_Configuration")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "chassis":
			return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis}, nil
		case "uuid":
			return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid}, nil
		case "sku_number", "skuNumber", "sku-number":
			return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber}, nil
		case "family":
			return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_System_Configuration", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_System_Configuration
func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
			values = append(values, source.Chassis)
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
			values = append(values, source.Uuid)
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
			values = append(values, source.SkuNumber)
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
			values = append(values, source.Family)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_System_Configuration
func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		return source.GetChassis(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		return source.GetUuid(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		return source.GetSkuNumber(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		return source.GetFamily(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
			item.Chassis = ""
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
			item.Uuid = ""
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
			item.SkuNumber = ""
		case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
			item.Family = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		return &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue allows storing values for Configuration fields according to their type
type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_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 Configuration field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Configuration' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) AsChassisValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) AsUuidValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) AsSkuNumberValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) AsFamilyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Configuration
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_System_Configuration) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		(*target).Chassis = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		(*target).Uuid = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		(*target).SkuNumber = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		(*target).Family = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_System_Configuration'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		leftValue := fpv.value.(string)
		rightValue := source.GetChassis()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		leftValue := fpv.value.(string)
		rightValue := source.GetUuid()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		leftValue := fpv.value.(string)
		rightValue := source.GetSkuNumber()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		leftValue := fpv.value.(string)
		rightValue := source.GetFamily()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_System_Configuration: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

// DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue allows storing single item in Path-specific values for Configuration according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_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 Configuration field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_System_Configuration as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Configuration'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_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
}

// DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues allows storing slice of values for Configuration fields according to their type
type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_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 Configuration field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues) AsChassisArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues) AsUuidArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues) AsSkuNumberArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPathArrayOfValues) AsFamilyArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor          DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel           DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities    DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads      DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores        DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName            DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial          DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 7
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz    DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 8
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 9
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo       DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 10
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver          DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 11
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency         DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 12
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock           DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector = 13
)

func (s DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		return "vendor"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		return "model"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return "capabilities"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		return "num_threads"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		return "num_cores"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		return "num_enabled_cores"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		return "serial"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		return "frequency_mhz"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		return "max_frequency_mhz"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return "cache_info"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		return "driver"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		return "latency"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		return "clock"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_CPU_Processor")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "vendor":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor}, nil
		case "model":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel}, nil
		case "capabilities":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities}, nil
		case "num_threads", "numThreads", "num-threads":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads}, nil
		case "num_cores", "numCores", "num-cores":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores}, nil
		case "num_enabled_cores", "numEnabledCores", "num-enabled-cores":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores}, nil
		case "name":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName}, nil
		case "serial":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial}, nil
		case "frequency_mhz", "frequencyMhz", "frequency-mhz":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz}, nil
		case "max_frequency_mhz", "maxFrequencyMhz", "max-frequency-mhz":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz}, nil
		case "cache_info", "cacheInfo", "cache-info":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo}, nil
		case "driver":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver}, nil
		case "latency":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency}, nil
		case "clock":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock}, nil
		}
	} else {
		switch fp[0] {
		case "capabilities":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationCapability_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities, subPath: subpath}, nil
			}
		case "cache_info", "cacheInfo", "cache-info":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_CPU_Processor", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_CPU_Processor
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
			values = append(values, source.Vendor)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
			values = append(values, source.Model)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
			for _, value := range source.GetCapabilities() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
			values = append(values, source.NumThreads)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
			values = append(values, source.NumCores)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
			values = append(values, source.NumEnabledCores)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
			values = append(values, source.Serial)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
			values = append(values, source.FrequencyMhz)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
			values = append(values, source.MaxFrequencyMhz)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
			for _, value := range source.GetCacheInfo() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
			values = append(values, source.Driver)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
			values = append(values, source.Latency)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
			values = append(values, source.Clock)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_CPU_Processor
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		return source.GetVendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		return source.GetModel(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		res := source.GetCapabilities()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		return source.GetNumThreads(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		return source.GetNumCores(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		return source.GetNumEnabledCores(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		return source.GetSerial(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		return source.GetFrequencyMhz(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		return source.GetMaxFrequencyMhz(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		res := source.GetCacheInfo()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		return source.GetDriver(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		return source.GetLatency(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		return source.GetClock(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_Capability)(nil)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		return uint32(0)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		return uint32(0)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		return uint32(0)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)(nil)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		return int64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
			item.Vendor = ""
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
			item.Model = ""
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
			item.Capabilities = nil
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
			item.NumThreads = uint32(0)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
			item.NumCores = uint32(0)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
			item.NumEnabledCores = uint32(0)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
			item.Serial = ""
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
			item.FrequencyMhz = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
			item.MaxFrequencyMhz = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
			item.CacheInfo = nil
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
			item.Driver = ""
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
			item.Latency = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
			item.Clock = int64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_Capability)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(uint32)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(uint32)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(uint32)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_Capability)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]uint32)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]uint32)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]uint32)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, values: values.([]int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_Capability)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) AsCapabilitiesSubPath() (DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationCapability_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) AsCacheInfoSubPath() (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_CPU_Processor
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		for _, item := range source.GetCapabilities() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		for _, item := range source.GetCacheInfo() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_CPU_Processor
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		if len(source.GetCapabilities()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetCapabilities()[0])
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		if len(source.GetCacheInfo()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetCacheInfo()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
			for _, subItem := range item.Capabilities {
				fps.subPath.ClearValueRaw(subItem)
			}
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
			for _, subItem := range item.CacheInfo {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue allows storing values for Processor fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_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 Processor field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Processor' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsVendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsModelValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsCapabilitiesValue() ([]*Device_Status_DeviceInfo_HardwareInformation_Capability, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Capability)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsNumThreadsValue() (uint32, bool) {
	res, ok := fpv.value.(uint32)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsNumCoresValue() (uint32, bool) {
	res, ok := fpv.value.(uint32)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsNumEnabledCoresValue() (uint32, bool) {
	res, ok := fpv.value.(uint32)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsSerialValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsFrequencyMhzValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsMaxFrequencyMhzValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsCacheInfoValue() ([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsDriverValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsLatencyValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) AsClockValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}

// SetTo stores value for selected field for object Processor
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		(*target).Vendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		(*target).Model = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		(*target).Capabilities = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Capability)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		(*target).NumThreads = fpv.value.(uint32)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		(*target).NumCores = fpv.value.(uint32)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		(*target).NumEnabledCores = fpv.value.(uint32)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		(*target).Serial = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		(*target).FrequencyMhz = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		(*target).MaxFrequencyMhz = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		(*target).CacheInfo = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		(*target).Driver = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		(*target).Latency = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		(*target).Clock = fpv.value.(int64)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_CPU_Processor'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetVendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		leftValue := fpv.value.(string)
		rightValue := source.GetModel()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		leftValue := fpv.value.(uint32)
		rightValue := source.GetNumThreads()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		leftValue := fpv.value.(uint32)
		rightValue := source.GetNumCores()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		leftValue := fpv.value.(uint32)
		rightValue := source.GetNumEnabledCores()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		leftValue := fpv.value.(string)
		rightValue := source.GetSerial()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		leftValue := fpv.value.(int64)
		rightValue := source.GetFrequencyMhz()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		leftValue := fpv.value.(int64)
		rightValue := source.GetMaxFrequencyMhz()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		leftValue := fpv.value.(string)
		rightValue := source.GetDriver()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		leftValue := fpv.value.(int64)
		rightValue := source.GetLatency()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		leftValue := fpv.value.(int64)
		rightValue := source.GetClock()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) AsCapabilitiesPathValue() (DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) AsCacheInfoPathValue() (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		panic("FieldPath setter is unsupported for array subpaths")
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return 0, false // repeated field
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue allows storing single item in Path-specific values for Processor according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_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 Processor field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_CPU_Processor as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue) AsCapabilitiesItemValue() (*Device_Status_DeviceInfo_HardwareInformation_Capability, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_Capability)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue) AsCacheInfoItemValue() (*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Processor'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationCPUProcessor_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 DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayItemValue) AsCapabilitiesPathItemValue() (DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayItemValue) AsCacheInfoPathItemValue() (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Processor'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		return false // repeated/map field
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues allows storing slice of values for Processor fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_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 Processor field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Capability) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads:
		for _, v := range fpaov.values.([]uint32) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores:
		for _, v := range fpaov.values.([]uint32) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores:
		for _, v := range fpaov.values.([]uint32) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsVendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsModelArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsCapabilitiesArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_Capability, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Capability)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsNumThreadsArrayOfValues() ([]uint32, bool) {
	res, ok := fpaov.values.([]uint32)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsNumCoresArrayOfValues() ([]uint32, bool) {
	res, ok := fpaov.values.([]uint32)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsNumEnabledCoresArrayOfValues() ([]uint32, bool) {
	res, ok := fpaov.values.([]uint32)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsSerialArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsFrequencyMhzArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsMaxFrequencyMhzArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsCacheInfoArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsDriverArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsLatencyArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPathArrayOfValues) AsClockArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayOfValues) AsCapabilitiesPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldSubPathArrayOfValues) AsCacheInfoPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType      DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		return "type"
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		return "size_bytes"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType}, nil
		case "size_bytes", "sizeBytes", "size-bytes":
			return &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
			values = append(values, source.Type)
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
			values = append(values, source.SizeBytes)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		return source.GetType(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		return source.GetSizeBytes(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		return int64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
			item.Type = ""
		case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
			item.SizeBytes = int64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath: *fp, value: value.(int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath: *fp, values: values.([]int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue allows storing values for Cache fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_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 Cache field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Cache' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) AsTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) AsSizeBytesValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}

// SetTo stores value for selected field for object Cache
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		(*target).SizeBytes = fpv.value.(int64)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		leftValue := fpv.value.(string)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSizeBytes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

// DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue allows storing single item in Path-specific values for Cache according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_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 Cache field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Cache'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_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
}

// DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues allows storing slice of values for Cache fields according to their type
type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_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 Cache field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPathArrayOfValues) AsSizeBytesArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block_Disk)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName         DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes    DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType    DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor       DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel        DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn          DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions   DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector = 7
)

func (s DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		return "size_bytes"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		return "drive_type"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		return "vendor"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		return "model"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		return "serial_number"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		return "wwn"
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return "partitions"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_Block_Disk")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName}, nil
		case "size_bytes", "sizeBytes", "size-bytes":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes}, nil
		case "drive_type", "driveType", "drive-type":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType}, nil
		case "vendor":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor}, nil
		case "model":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel}, nil
		case "serial_number", "serialNumber", "serial-number":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber}, nil
		case "wwn":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn}, nil
		case "partitions":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions}, nil
		}
	} else {
		switch fp[0] {
		case "partitions":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_Block_Disk", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_Block_Disk
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
			values = append(values, source.SizeBytes)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
			values = append(values, source.DriveType)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
			values = append(values, source.Vendor)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
			values = append(values, source.Model)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
			values = append(values, source.SerialNumber)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
			values = append(values, source.Wwn)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
			for _, value := range source.GetPartitions() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_Block_Disk
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		return source.GetSizeBytes(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		return source.GetDriveType(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		return source.GetVendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		return source.GetModel(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		return source.GetSerialNumber(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		return source.GetWwn(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		res := source.GetPartitions()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return ([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
			item.SizeBytes = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
			item.DriveType = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
			item.Vendor = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
			item.Model = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
			item.SerialNumber = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
			item.Wwn = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
			item.Partitions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, values: values.([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) AsPartitionsSubPath() (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_Block_Disk
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		for _, item := range source.GetPartitions() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_Block_Disk
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		if len(source.GetPartitions()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetPartitions()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
			for _, subItem := range item.Partitions {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue allows storing values for Disk fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_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 Disk field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Disk' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsSizeBytesValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsDriveTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsVendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsModelValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsSerialNumberValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsWwnValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) AsPartitionsValue() ([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition, bool) {
	res, ok := fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	return res, ok
}

// SetTo stores value for selected field for object Disk
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block_Disk) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		(*target).SizeBytes = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		(*target).DriveType = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		(*target).Vendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		(*target).Model = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		(*target).SerialNumber = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		(*target).Wwn = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		(*target).Partitions = fpv.value.([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Block_Disk'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSizeBytes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		leftValue := fpv.value.(string)
		rightValue := source.GetDriveType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetVendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		leftValue := fpv.value.(string)
		rightValue := source.GetModel()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		leftValue := fpv.value.(string)
		rightValue := source.GetSerialNumber()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		leftValue := fpv.value.(string)
		rightValue := source.GetWwn()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue) AsPartitionsPathValue() (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block_Disk) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue allows storing single item in Path-specific values for Disk according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_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 Disk field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_Block_Disk as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue) AsPartitionsItemValue() (*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition, bool) {
	res, ok := fpaiv.value.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Disk'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationBlockDisk_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 DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayItemValue) AsPartitionsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Disk'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues allows storing slice of values for Disk fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_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 Disk field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions:
		for _, v := range fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsSizeBytesArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsDriveTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsVendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsModelArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsSerialNumberArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsWwnArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPathArrayOfValues) AsPartitionsArrayOfValues() ([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition, bool) {
	res, ok := fpaov.values.([][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldSubPathArrayOfValues) AsPartitionsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName       DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes  DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType       DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector = 3
)

func (s DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		return "size_bytes"
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		return "mount_point"
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		return "type"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName}, nil
		case "size_bytes", "sizeBytes", "size-bytes":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes}, nil
		case "mount_point", "mountPoint", "mount-point":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint}, nil
		case "type":
			return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
			values = append(values, source.SizeBytes)
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
			values = append(values, source.MountPoint)
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
			values = append(values, source.Type)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		return source.GetSizeBytes(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		return source.GetMountPoint(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		return source.GetType(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
			item.SizeBytes = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
			item.MountPoint = ""
		case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
			item.Type = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		return &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue allows storing values for Partition fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_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 Partition field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Partition' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) AsSizeBytesValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) AsMountPointValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) AsTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Partition
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		(*target).SizeBytes = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		(*target).MountPoint = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSizeBytes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		leftValue := fpv.value.(string)
		rightValue := source.GetMountPoint()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		leftValue := fpv.value.(string)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

// DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue allows storing single item in Path-specific values for Partition according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_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 Partition field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Partition'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_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
}

// DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues allows storing slice of values for Partition fields according to their type
type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_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 Partition field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues) AsSizeBytesArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues) AsMountPointArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Network_NIC)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName        DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress  DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual     DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor      DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor   DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting     DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector = 7
)

func (s DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		return "mac_address"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		return "virtual"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		return "description"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		return "product_name"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		return "vendor"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		return "subvendor"
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return "setting"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_Network_NIC")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName}, nil
		case "mac_address", "macAddress", "mac-address":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress}, nil
		case "virtual":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual}, nil
		case "description":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription}, nil
		case "product_name", "productName", "product-name":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName}, nil
		case "vendor":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor}, nil
		case "subvendor":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor}, nil
		case "setting":
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting}, nil
		}
	} else {
		switch fp[0] {
		case "setting":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Device_Status_DeviceInfo_HardwareInformation_Network_NIC)", fp)
			}
			return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_Network_NIC", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_Network_NIC
func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
			values = append(values, source.MacAddress)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
			values = append(values, source.Virtual)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
			values = append(values, source.ProductName)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
			values = append(values, source.Vendor)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
			values = append(values, source.Subvendor)
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
			values = append(values, source.Setting)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_Network_NIC
func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		return source.GetMacAddress(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		return source.GetVirtual(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		return source.GetProductName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		return source.GetVendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		return source.GetSubvendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		res := source.GetSetting()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		return false
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return (map[string]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
			item.MacAddress = ""
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
			item.Virtual = false
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
			item.Description = ""
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
			item.ProductName = ""
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
			item.Vendor = ""
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
			item.Subvendor = ""
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
			item.Setting = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(bool)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, value: value.(map[string]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]bool)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// FieldPath for map type with additional Key information
type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap struct {
	key      string
	selector DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap)(nil)

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) Selector() DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelector {
	return fpm.selector
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) Key() string {
	return fpm.key
}

// String returns path representation in proto convention
func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_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 *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

// Get returns all values pointed by selected field map key from source Device_Status_DeviceInfo_HardwareInformation_Network_NIC
func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) Get(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (values []interface{}) {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		if value, ok := source.GetSetting()[fpm.key]; ok {
			values = append(values, value)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
	}
	return
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) GetRaw(source proto.Message) []interface{} {
	return fpm.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// GetSingle returns value by selected field map key from source Device_Status_DeviceInfo_HardwareInformation_Network_NIC
func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (interface{}, bool) {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		res, ok := source.GetSetting()[fpm.key]
		return res, ok
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpm.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// GetDefault returns a default value of the field type
func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		var v string
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) {
	if item != nil {
		switch fpm.selector {
		case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
			delete(item.Setting, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
		}
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// IsLeaf - whether field path is holds simple value
func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) IsLeaf() bool {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return true
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fpm}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fpm.WithIValue(value)
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fpm.WithIArrayOfValues(values)
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue {
	panic("Cannot create array item value from map fieldpath")
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fpm.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue allows storing values for NIC fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_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 NIC field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NIC' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsMacAddressValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsVirtualValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsProductNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsVendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsSubvendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) AsSettingValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}

// SetTo stores value for selected field for object NIC
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Network_NIC) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		(*target).MacAddress = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		(*target).Virtual = fpv.value.(bool)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		(*target).ProductName = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		(*target).Vendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		(*target).Subvendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		(*target).Setting = fpv.value.(map[string]string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Network_NIC'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		leftValue := fpv.value.(string)
		rightValue := source.GetMacAddress()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		leftValue := fpv.value.(bool)
		rightValue := source.GetVirtual()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_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 DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		leftValue := fpv.value.(string)
		rightValue := source.GetProductName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetVendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetSubvendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in NIC as interface{}
func (fpmv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue) AsSettingElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}

// SetTo stores value for selected field in NIC
func (fpmv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_Network_NIC) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	}
	switch fpmv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		if (*target).Setting == nil {
			(*target).Setting = make(map[string]string)
		}
		(*target).Setting[fpmv.key] = fpmv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpmv.selector))
	}
}

func (fpmv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
	fpmv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_Network_NIC'.
func (fpmv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (int, bool) {
	switch fpmv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		leftValue := fpmv.value.(string)
		rightValue := source.GetSetting()[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 Device_Status_DeviceInfo_HardwareInformation_Network_NIC: %d", fpmv.selector))
	}
}

func (fpmv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpmv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue allows storing single item in Path-specific values for NIC according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_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 NIC field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_Network_NIC as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

// Contains returns a boolean indicating if value that is being held is present in given 'NIC'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationNetworkNIC_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
}

// DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues allows storing slice of values for NIC fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_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 NIC field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsMacAddressArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsVirtualArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsProductNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsVendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsSubvendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPathArrayOfValues) AsSettingArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMap
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapArrayOfValues)(nil)

func (fpmaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathMapArrayOfValues) AsSettingArrayOfElementValues() ([]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 DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex  DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		return "index"
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return "device"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "index":
			return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex}, nil
		case "device":
			return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice}, nil
		}
	} else {
		switch fp[0] {
		case "device":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard
func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
			values = append(values, source.Index)
		case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
			if source.Device != nil {
				values = append(values, source.Device)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard
func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		return source.GetIndex(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		res := source.GetDevice()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return (*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
			item.Index = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
			item.Device = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) AsDeviceSubPath() (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		values = append(values, fps.subPath.GetRaw(source.GetDevice())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		if source.GetDevice() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDevice())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
			fps.subPath.ClearValueRaw(item.Device)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue allows storing values for GraphicCard fields according to their type
type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_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 GraphicCard field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'GraphicCard' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) AsIndexValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) AsDeviceValue() (*Device_Status_DeviceInfo_HardwareInformation_PCIDevice, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
	return res, ok
}

// SetTo stores value for selected field for object GraphicCard
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		(*target).Index = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		(*target).Device = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		leftValue := fpv.value.(int64)
		rightValue := source.GetIndex()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue) AsDevicePathValue() (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue).SetTo(&(*target).Device)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathValue).CompareWith(source.GetDevice())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue allows storing single item in Path-specific values for GraphicCard according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_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 GraphicCard field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

// Contains returns a boolean indicating if value that is being held is present in given 'GraphicCard'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_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 DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayItemValue) AsDevicePathItemValue() (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'GraphicCard'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayItemValue).ContainsValue(source.GetDevice())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues allows storing slice of values for GraphicCard fields according to their type
type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_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 GraphicCard field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_PCIDevice) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues) AsIndexArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPathArrayOfValues) AsDeviceArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_PCIDevice, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPathArrayOfValues) AsDevicePathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct     DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor      DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial      DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot        DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes   DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits   DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector = 7
)

func (s DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		return "description"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		return "product"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		return "vendor"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		return "serial"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		return "slot"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		return "size_bytes"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		return "frequency_hz"
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		return "width_bits"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription}, nil
		case "product":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct}, nil
		case "vendor":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor}, nil
		case "serial":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial}, nil
		case "slot":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot}, nil
		case "size_bytes", "sizeBytes", "size-bytes":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes}, nil
		case "frequency_hz", "frequencyHz", "frequency-hz":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz}, nil
		case "width_bits", "widthBits", "width-bits":
			return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
			values = append(values, source.Product)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
			values = append(values, source.Vendor)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
			values = append(values, source.Serial)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
			values = append(values, source.Slot)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
			values = append(values, source.SizeBytes)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
			values = append(values, source.FrequencyHz)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
			values = append(values, source.WidthBits)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		return source.GetProduct(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		return source.GetVendor(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		return source.GetSerial(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		return source.GetSlot(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		return source.GetSizeBytes(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		return source.GetFrequencyHz(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		return source.GetWidthBits(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		return int64(0)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
			item.Description = ""
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
			item.Product = ""
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
			item.Vendor = ""
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
			item.Serial = ""
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
			item.Slot = ""
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
			item.SizeBytes = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
			item.FrequencyHz = int64(0)
		case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
			item.WidthBits = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(int64)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]int64)}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		return &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue allows storing values for MemoryBank fields according to their type
type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_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 MemoryBank field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'MemoryBank' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsProductValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsVendorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsSerialValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsSlotValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsSizeBytesValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsFrequencyHzValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) AsWidthBitsValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object MemoryBank
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		(*target).Product = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		(*target).Vendor = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		(*target).Serial = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		(*target).Slot = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		(*target).SizeBytes = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		(*target).FrequencyHz = fpv.value.(int64)
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		(*target).WidthBits = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_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 DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		leftValue := fpv.value.(string)
		rightValue := source.GetProduct()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		leftValue := fpv.value.(string)
		rightValue := source.GetVendor()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		leftValue := fpv.value.(string)
		rightValue := source.GetSerial()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		leftValue := fpv.value.(string)
		rightValue := source.GetSlot()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSizeBytes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		leftValue := fpv.value.(int64)
		rightValue := source.GetFrequencyHz()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		leftValue := fpv.value.(int32)
		rightValue := source.GetWidthBits()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

// DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue allows storing single item in Path-specific values for MemoryBank according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_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 MemoryBank field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

// Contains returns a boolean indicating if value that is being held is present in given 'MemoryBank'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_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
}

// DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues allows storing slice of values for MemoryBank fields according to their type
type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_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 MemoryBank field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsProductArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsVendorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsSerialArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsSlotArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsSizeBytesArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsFrequencyHzArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPathArrayOfValues) AsWidthBitsArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId                      DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion        DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion            DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion              DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName                  DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber               DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber                 DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName                DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 7
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector = 8
)

func (s DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		return "dev_id"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		return "control_proto_version"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		return "firmware_version"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		return "logger_version"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		return "board_name"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		return "serial_number"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		return "part_number"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		return "product_name"
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		return "neural_network_core_clock_rate"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "dev_id", "devId", "dev-id":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId}, nil
		case "control_proto_version", "controlProtoVersion", "control-proto-version":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion}, nil
		case "firmware_version", "firmwareVersion", "firmware-version":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion}, nil
		case "logger_version", "loggerVersion", "logger-version":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion}, nil
		case "board_name", "boardName", "board-name":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName}, nil
		case "serial_number", "serialNumber", "serial-number":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber}, nil
		case "part_number", "partNumber", "part-number":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber}, nil
		case "product_name", "productName", "product-name":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName}, nil
		case "neural_network_core_clock_rate", "neuralNetworkCoreClockRate", "neural-network-core-clock-rate":
			return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
			values = append(values, source.DevId)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
			values = append(values, source.ControlProtoVersion)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
			values = append(values, source.FirmwareVersion)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
			values = append(values, source.LoggerVersion)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
			values = append(values, source.BoardName)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
			values = append(values, source.SerialNumber)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
			values = append(values, source.PartNumber)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
			values = append(values, source.ProductName)
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
			values = append(values, source.NeuralNetworkCoreClockRate)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		return source.GetDevId(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		return source.GetControlProtoVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		return source.GetFirmwareVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		return source.GetLoggerVersion(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		return source.GetBoardName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		return source.GetSerialNumber(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		return source.GetPartNumber(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		return source.GetProductName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		return source.GetNeuralNetworkCoreClockRate(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
			item.DevId = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
			item.ControlProtoVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
			item.FirmwareVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
			item.LoggerVersion = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
			item.BoardName = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
			item.SerialNumber = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
			item.PartNumber = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
			item.ProductName = ""
		case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
			item.NeuralNetworkCoreClockRate = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		return &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue allows storing values for HailoModuleInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_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 HailoModuleInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'HailoModuleInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsDevIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsControlProtoVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsFirmwareVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsLoggerVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsBoardNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsSerialNumberValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsPartNumberValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsProductNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) AsNeuralNetworkCoreClockRateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object HailoModuleInfo
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		(*target).DevId = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		(*target).ControlProtoVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		(*target).FirmwareVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		(*target).LoggerVersion = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		(*target).BoardName = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		(*target).SerialNumber = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		(*target).PartNumber = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		(*target).ProductName = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		(*target).NeuralNetworkCoreClockRate = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		leftValue := fpv.value.(string)
		rightValue := source.GetDevId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetControlProtoVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetFirmwareVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetLoggerVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		leftValue := fpv.value.(string)
		rightValue := source.GetBoardName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		leftValue := fpv.value.(string)
		rightValue := source.GetSerialNumber()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		leftValue := fpv.value.(string)
		rightValue := source.GetPartNumber()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		leftValue := fpv.value.(string)
		rightValue := source.GetProductName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		leftValue := fpv.value.(string)
		rightValue := source.GetNeuralNetworkCoreClockRate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

// DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue allows storing single item in Path-specific values for HailoModuleInfo according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_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 HailoModuleInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

// Contains returns a boolean indicating if value that is being held is present in given 'HailoModuleInfo'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_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
}

// DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues allows storing slice of values for HailoModuleInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_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 HailoModuleInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsDevIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsControlProtoVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsFirmwareVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsLoggerVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsBoardNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsSerialNumberArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsPartNumberArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsProductNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPathArrayOfValues) AsNeuralNetworkCoreClockRateArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId          DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		return "id"
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		return "product_name"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "id":
			return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId}, nil
		case "product_name", "productName", "product-name":
			return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
			values = append(values, source.Id)
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
			values = append(values, source.ProductName)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		return source.GetId(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		return source.GetProductName(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
			item.Id = ""
		case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
			item.ProductName = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		return &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue allows storing values for GpuInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_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 GpuInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'GpuInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) AsIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) AsProductNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object GpuInfo
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		(*target).Id = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		(*target).ProductName = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		leftValue := fpv.value.(string)
		rightValue := source.GetId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		leftValue := fpv.value.(string)
		rightValue := source.GetProductName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

// DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue allows storing single item in Path-specific values for GpuInfo according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_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 GpuInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

// Contains returns a boolean indicating if value that is being held is present in given 'GpuInfo'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_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
}

// DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues allows storing slice of values for GpuInfo fields according to their type
type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_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 GpuInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues) AsIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPathArrayOfValues) AsProductNameArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		return "drx_cycle"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		return "mico_mode"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "drx_cycle", "drxCycle", "drx-cycle":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle}, nil
		case "mico_mode", "micoMode", "mico-mode":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
			values = append(values, source.DrxCycle)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
			values = append(values, source.MicoMode)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		return source.GetDrxCycle(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		return source.GetMicoMode(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
			item.DrxCycle = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
			item.MicoMode = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue allows storing values for RegistrationSettings fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_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 RegistrationSettings field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RegistrationSettings' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) AsDrxCycleValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) AsMicoModeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RegistrationSettings
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		(*target).DrxCycle = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		(*target).MicoMode = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		leftValue := fpv.value.(string)
		rightValue := source.GetDrxCycle()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		leftValue := fpv.value.(string)
		rightValue := source.GetMicoMode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue allows storing single item in Path-specific values for RegistrationSettings according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_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 RegistrationSettings field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

// Contains returns a boolean indicating if value that is being held is present in given 'RegistrationSettings'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_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
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues allows storing slice of values for RegistrationSettings fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_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 RegistrationSettings field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues) AsDrxCycleArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPathArrayOfValues) AsMicoModeArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector = 0
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return "registration_settings"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "registration_settings", "registrationSettings", "registration-settings":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings}, nil
		}
	} else {
		switch fp[0] {
		case "registration_settings", "registrationSettings", "registration-settings":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
			if source.RegistrationSettings != nil {
				values = append(values, source.RegistrationSettings)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		res := source.GetRegistrationSettings()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
			item.RegistrationSettings = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) AsRegistrationSettingsSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		values = append(values, fps.subPath.GetRaw(source.GetRegistrationSettings())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		if source.GetRegistrationSettings() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRegistrationSettings())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
			fps.subPath.ClearValueRaw(item.RegistrationSettings)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue allows storing values for FiveGNr fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_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 FiveGNr field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'FiveGNr' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue) AsRegistrationSettingsValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
	return res, ok
}

// SetTo stores value for selected field for object FiveGNr
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		(*target).RegistrationSettings = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue) AsRegistrationSettingsPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue).SetTo(&(*target).RegistrationSettings)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathValue).CompareWith(source.GetRegistrationSettings())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue allows storing single item in Path-specific values for FiveGNr according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_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 FiveGNr field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

// Contains returns a boolean indicating if value that is being held is present in given 'FiveGNr'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_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 DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayItemValue) AsRegistrationSettingsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'FiveGNr'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayItemValue).ContainsValue(source.GetRegistrationSettings())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues allows storing slice of values for FiveGNr fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_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 FiveGNr field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPathArrayOfValues) AsRegistrationSettingsArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPathArrayOfValues) AsRegistrationSettingsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn      DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType   DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser     DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector = 3
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		return "apn"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		return "ip_type"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		return "password"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		return "user"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "apn":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn}, nil
		case "ip_type", "ipType", "ip-type":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType}, nil
		case "password":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword}, nil
		case "user":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
			values = append(values, source.Apn)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
			values = append(values, source.IpType)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
			values = append(values, source.Password)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
			values = append(values, source.User)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		return source.GetApn(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		return source.GetIpType(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		return source.GetPassword(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		return source.GetUser(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
			item.Apn = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
			item.IpType = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
			item.Password = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
			item.User = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue allows storing values for Settings fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_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 Settings field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Settings' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) AsApnValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) AsIpTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) AsPasswordValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) AsUserValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Settings
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		(*target).Apn = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		(*target).IpType = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		(*target).Password = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		(*target).User = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		leftValue := fpv.value.(string)
		rightValue := source.GetApn()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		leftValue := fpv.value.(string)
		rightValue := source.GetIpType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		leftValue := fpv.value.(string)
		rightValue := source.GetPassword()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		leftValue := fpv.value.(string)
		rightValue := source.GetUser()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue allows storing single item in Path-specific values for Settings according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_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 Settings field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Settings'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_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
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues allows storing slice of values for Settings fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_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 Settings field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues) AsApnArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues) AsIpTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues) AsPasswordArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPathArrayOfValues) AsUserArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		return "dbus_path"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return "settings"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "dbus_path", "dbusPath", "dbus-path":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath}, nil
		case "settings":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings}, nil
		}
	} else {
		switch fp[0] {
		case "settings":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
			values = append(values, source.DbusPath)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
			if source.Settings != nil {
				values = append(values, source.Settings)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		return source.GetDbusPath(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		res := source.GetSettings()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
			item.DbusPath = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
			item.Settings = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) AsSettingsSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		values = append(values, fps.subPath.GetRaw(source.GetSettings())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		if source.GetSettings() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSettings())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
			fps.subPath.ClearValueRaw(item.Settings)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue allows storing values for InitialBearer fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_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 InitialBearer field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'InitialBearer' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) AsDbusPathValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) AsSettingsValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
	return res, ok
}

// SetTo stores value for selected field for object InitialBearer
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		(*target).DbusPath = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		(*target).Settings = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		leftValue := fpv.value.(string)
		rightValue := source.GetDbusPath()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue) AsSettingsPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue).SetTo(&(*target).Settings)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathValue).CompareWith(source.GetSettings())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue allows storing single item in Path-specific values for InitialBearer according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_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 InitialBearer field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

// Contains returns a boolean indicating if value that is being held is present in given 'InitialBearer'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_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 DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayItemValue) AsSettingsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'InitialBearer'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayItemValue).ContainsValue(source.GetSettings())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues allows storing slice of values for InitialBearer fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_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 InitialBearer field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues) AsDbusPathArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPathArrayOfValues) AsSettingsArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPathArrayOfValues) AsSettingsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer   DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return "initial_bearer"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		return "ue_mode_operation"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "initial_bearer", "initialBearer", "initial-bearer":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer}, nil
		case "ue_mode_operation", "ueModeOperation", "ue-mode-operation":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation}, nil
		}
	} else {
		switch fp[0] {
		case "initial_bearer", "initialBearer", "initial-bearer":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
			if source.InitialBearer != nil {
				values = append(values, source.InitialBearer)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
			values = append(values, source.UeModeOperation)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		res := source.GetInitialBearer()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		return source.GetUeModeOperation(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
			item.InitialBearer = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
			item.UeModeOperation = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) AsInitialBearerSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		values = append(values, fps.subPath.GetRaw(source.GetInitialBearer())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		if source.GetInitialBearer() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetInitialBearer())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
			fps.subPath.ClearValueRaw(item.InitialBearer)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue allows storing values for Eps fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_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 Eps field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Eps' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) AsInitialBearerValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) AsUeModeOperationValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Eps
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		(*target).InitialBearer = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		(*target).UeModeOperation = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		leftValue := fpv.value.(string)
		rightValue := source.GetUeModeOperation()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue) AsInitialBearerPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue).SetTo(&(*target).InitialBearer)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathValue).CompareWith(source.GetInitialBearer())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue allows storing single item in Path-specific values for Eps according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_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 Eps field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Eps'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusEps_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 DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayItemValue) AsInitialBearerPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Eps'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayItemValue).ContainsValue(source.GetInitialBearer())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues allows storing slice of values for Eps fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_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 Eps field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues) AsInitialBearerArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPathArrayOfValues) AsUeModeOperationArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPathArrayOfValues) AsInitialBearerPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr            DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks       DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps                DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei               DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode       DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName       DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco                DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 7
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState  DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector = 8
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return "fiveg_nr"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		return "enabled_locks"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return "eps"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		return "imei"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		return "operator_code"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		return "operator_name"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		return "packet_service_state"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		return "pco"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		return "registration_state"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "fiveg_nr", "fivegNr", "fiveg-nr":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr}, nil
		case "enabled_locks", "enabledLocks", "enabled-locks":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks}, nil
		case "eps":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps}, nil
		case "imei":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei}, nil
		case "operator_code", "operatorCode", "operator-code":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode}, nil
		case "operator_name", "operatorName", "operator-name":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName}, nil
		case "packet_service_state", "packetServiceState", "packet-service-state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState}, nil
		case "pco":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco}, nil
		case "registration_state", "registrationState", "registration-state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState}, nil
		}
	} else {
		switch fp[0] {
		case "fiveg_nr", "fivegNr", "fiveg-nr":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr, subPath: subpath}, nil
			}
		case "eps":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
			if source.FivegNr != nil {
				values = append(values, source.FivegNr)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
			for _, value := range source.GetEnabledLocks() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
			if source.Eps != nil {
				values = append(values, source.Eps)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
			values = append(values, source.Imei)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
			values = append(values, source.OperatorCode)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
			values = append(values, source.OperatorName)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
			values = append(values, source.PacketServiceState)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
			values = append(values, source.Pco)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
			values = append(values, source.RegistrationState)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		res := source.GetFivegNr()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		res := source.GetEnabledLocks()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		res := source.GetEps()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		return source.GetImei(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		return source.GetOperatorCode(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		return source.GetOperatorName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		return source.GetPacketServiceState(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		return source.GetPco(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		return source.GetRegistrationState(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
			item.FivegNr = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
			item.EnabledLocks = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
			item.Eps = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
			item.Imei = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
			item.OperatorCode = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
			item.OperatorName = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
			item.PacketServiceState = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
			item.Pco = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
			item.RegistrationState = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) AsFivegNrSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) AsEpsSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		values = append(values, fps.subPath.GetRaw(source.GetFivegNr())...)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		values = append(values, fps.subPath.GetRaw(source.GetEps())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		if source.GetFivegNr() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetFivegNr())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		if source.GetEps() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetEps())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
			fps.subPath.ClearValueRaw(item.FivegNr)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
			fps.subPath.ClearValueRaw(item.Eps)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue allows storing values for ThreeGpp fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_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 ThreeGpp field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ThreeGpp' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsFivegNrValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsEnabledLocksValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsEpsValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsImeiValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsOperatorCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsOperatorNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsPacketServiceStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsPcoValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) AsRegistrationStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object ThreeGpp
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		(*target).FivegNr = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		(*target).EnabledLocks = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		(*target).Eps = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		(*target).Imei = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		(*target).OperatorCode = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		(*target).OperatorName = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		(*target).PacketServiceState = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		(*target).Pco = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		(*target).RegistrationState = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		leftValue := fpv.value.(string)
		rightValue := source.GetImei()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatorCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatorName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		leftValue := fpv.value.(string)
		rightValue := source.GetPacketServiceState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		leftValue := fpv.value.(string)
		rightValue := source.GetPco()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		leftValue := fpv.value.(string)
		rightValue := source.GetRegistrationState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) AsFivegNrPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) AsEpsPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue).SetTo(&(*target).FivegNr)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue).SetTo(&(*target).Eps)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathValue).CompareWith(source.GetFivegNr())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathValue).CompareWith(source.GetEps())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue allows storing single item in Path-specific values for ThreeGpp according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_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 ThreeGpp field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue) AsEnabledLocksItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ThreeGpp'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_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 DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayItemValue) AsFivegNrPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayItemValue) AsEpsPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ThreeGpp'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayItemValue).ContainsValue(source.GetFivegNr())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayItemValue).ContainsValue(source.GetEps())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues allows storing slice of values for ThreeGpp fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_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 ThreeGpp field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsFivegNrArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsEnabledLocksArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsEpsArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsImeiArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsOperatorCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsOperatorNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsPacketServiceStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsPcoArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPathArrayOfValues) AsRegistrationStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayOfValues) AsFivegNrPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPathArrayOfValues) AsEpsPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState         DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn                     DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState   DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid                    DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid                     DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid                     DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector = 6
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		return "activation_state"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		return "cdma1x_registration_state"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		return "esn"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		return "evdo_registration_state"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		return "meid"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		return "nid"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		return "sid"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "activation_state", "activationState", "activation-state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState}, nil
		case "cdma1x_registration_state", "cdma1xRegistrationState", "cdma1x-registration-state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState}, nil
		case "esn":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn}, nil
		case "evdo_registration_state", "evdoRegistrationState", "evdo-registration-state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState}, nil
		case "meid":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid}, nil
		case "nid":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid}, nil
		case "sid":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
			values = append(values, source.ActivationState)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
			values = append(values, source.Cdma1XRegistrationState)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
			values = append(values, source.Esn)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
			values = append(values, source.EvdoRegistrationState)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
			values = append(values, source.Meid)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
			values = append(values, source.Nid)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
			values = append(values, source.Sid)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		return source.GetActivationState(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		return source.GetCdma1XRegistrationState(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		return source.GetEsn(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		return source.GetEvdoRegistrationState(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		return source.GetMeid(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		return source.GetNid(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		return source.GetSid(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
			item.ActivationState = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
			item.Cdma1XRegistrationState = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
			item.Esn = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
			item.EvdoRegistrationState = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
			item.Meid = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
			item.Nid = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
			item.Sid = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue allows storing values for Cdma fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_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 Cdma field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Cdma' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsActivationStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsCdma1xRegistrationStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsEsnValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsEvdoRegistrationStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsMeidValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsNidValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) AsSidValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Cdma
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		(*target).ActivationState = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		(*target).Cdma1XRegistrationState = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		(*target).Esn = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		(*target).EvdoRegistrationState = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		(*target).Meid = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		(*target).Nid = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		(*target).Sid = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		leftValue := fpv.value.(string)
		rightValue := source.GetActivationState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		leftValue := fpv.value.(string)
		rightValue := source.GetCdma1XRegistrationState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		leftValue := fpv.value.(string)
		rightValue := source.GetEsn()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		leftValue := fpv.value.(string)
		rightValue := source.GetEvdoRegistrationState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		leftValue := fpv.value.(string)
		rightValue := source.GetMeid()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		leftValue := fpv.value.(string)
		rightValue := source.GetNid()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		leftValue := fpv.value.(string)
		rightValue := source.GetSid()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue allows storing single item in Path-specific values for Cdma according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_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 Cdma field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Cdma'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_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
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues allows storing slice of values for Cdma fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_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 Cdma field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsActivationStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsCdma1xRegistrationStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsEsnArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsEvdoRegistrationStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsMeidArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsNidArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPathArrayOfValues) AsSidArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue  DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector = 1
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		return "recent"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		return "value"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "recent":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent}, nil
		case "value":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
			values = append(values, source.Recent)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
			values = append(values, source.Value)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		return source.GetRecent(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		return source.GetValue(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
			item.Recent = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
			item.Value = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue allows storing values for SignalQuality fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_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 SignalQuality field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'SignalQuality' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) AsRecentValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) AsValueValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object SignalQuality
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		(*target).Recent = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		(*target).Value = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		leftValue := fpv.value.(string)
		rightValue := source.GetRecent()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		leftValue := fpv.value.(string)
		rightValue := source.GetValue()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue allows storing single item in Path-specific values for SignalQuality according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_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 SignalQuality field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

// Contains returns a boolean indicating if value that is being held is present in given 'SignalQuality'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_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
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues allows storing slice of values for SignalQuality fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_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 SignalQuality field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues) AsRecentArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies           DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers                      DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration         DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands                 DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities          DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes                 DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice                       DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 7
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier             DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 8
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers                      DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 9
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier          DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 10
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision             DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 11
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer                 DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 12
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel                        DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 13
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers                   DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 14
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin                       DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 15
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts                        DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 16
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState                   DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 17
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort                  DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 18
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot               DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 19
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision                     DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 20
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality                DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 21
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim                          DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 22
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots                     DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 23
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState                        DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 24
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason            DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 25
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands               DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 26
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities        DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 27
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies          DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 28
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes               DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 29
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired               DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 30
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries                DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector = 31
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		return "access_technologies"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		return "bearers"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		return "carrier_configuration"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		return "carrier_configuration_revision"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		return "current_bands"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		return "current_capabilities"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		return "current_modes"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		return "device"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		return "device_identifier"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		return "drivers"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		return "equipment_identifier"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		return "hardware_revision"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		return "manufacturer"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		return "model"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		return "own_numbers"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		return "plugin"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		return "ports"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		return "power_state"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		return "primary_port"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		return "primary_sim_slot"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		return "revision"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return "signal_quality"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		return "sim"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		return "sim_slots"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		return "state"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		return "state_failed_reason"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		return "supported_bands"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		return "supported_capabilities"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		return "supported_ip_families"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		return "supported_modes"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		return "unlock_required"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		return "unlock_retries"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "access_technologies", "accessTechnologies", "access-technologies":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies}, nil
		case "bearers":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers}, nil
		case "carrier_configuration", "carrierConfiguration", "carrier-configuration":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration}, nil
		case "carrier_configuration_revision", "carrierConfigurationRevision", "carrier-configuration-revision":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision}, nil
		case "current_bands", "currentBands", "current-bands":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands}, nil
		case "current_capabilities", "currentCapabilities", "current-capabilities":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities}, nil
		case "current_modes", "currentModes", "current-modes":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes}, nil
		case "device":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice}, nil
		case "device_identifier", "deviceIdentifier", "device-identifier":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier}, nil
		case "drivers":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers}, nil
		case "equipment_identifier", "equipmentIdentifier", "equipment-identifier":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier}, nil
		case "hardware_revision", "hardwareRevision", "hardware-revision":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision}, nil
		case "manufacturer":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer}, nil
		case "model":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel}, nil
		case "own_numbers", "ownNumbers", "own-numbers":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers}, nil
		case "plugin":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin}, nil
		case "ports":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts}, nil
		case "power_state", "powerState", "power-state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState}, nil
		case "primary_port", "primaryPort", "primary-port":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort}, nil
		case "primary_sim_slot", "primarySimSlot", "primary-sim-slot":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot}, nil
		case "revision":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision}, nil
		case "signal_quality", "signalQuality", "signal-quality":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality}, nil
		case "sim":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim}, nil
		case "sim_slots", "simSlots", "sim-slots":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots}, nil
		case "state":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState}, nil
		case "state_failed_reason", "stateFailedReason", "state-failed-reason":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason}, nil
		case "supported_bands", "supportedBands", "supported-bands":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands}, nil
		case "supported_capabilities", "supportedCapabilities", "supported-capabilities":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities}, nil
		case "supported_ip_families", "supportedIpFamilies", "supported-ip-families":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies}, nil
		case "supported_modes", "supportedModes", "supported-modes":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes}, nil
		case "unlock_required", "unlockRequired", "unlock-required":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired}, nil
		case "unlock_retries", "unlockRetries", "unlock-retries":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries}, nil
		}
	} else {
		switch fp[0] {
		case "signal_quality", "signalQuality", "signal-quality":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
			for _, value := range source.GetAccessTechnologies() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
			for _, value := range source.GetBearers() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
			values = append(values, source.CarrierConfiguration)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
			values = append(values, source.CarrierConfigurationRevision)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
			for _, value := range source.GetCurrentBands() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
			for _, value := range source.GetCurrentCapabilities() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
			values = append(values, source.CurrentModes)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
			values = append(values, source.Device)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
			values = append(values, source.DeviceIdentifier)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
			for _, value := range source.GetDrivers() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
			values = append(values, source.EquipmentIdentifier)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
			values = append(values, source.HardwareRevision)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
			values = append(values, source.Manufacturer)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
			values = append(values, source.Model)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
			for _, value := range source.GetOwnNumbers() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
			values = append(values, source.Plugin)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
			for _, value := range source.GetPorts() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
			values = append(values, source.PowerState)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
			values = append(values, source.PrimaryPort)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
			values = append(values, source.PrimarySimSlot)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
			values = append(values, source.Revision)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
			if source.SignalQuality != nil {
				values = append(values, source.SignalQuality)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
			values = append(values, source.Sim)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
			for _, value := range source.GetSimSlots() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
			values = append(values, source.State)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
			values = append(values, source.StateFailedReason)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
			for _, value := range source.GetSupportedBands() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
			for _, value := range source.GetSupportedCapabilities() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
			for _, value := range source.GetSupportedIpFamilies() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
			for _, value := range source.GetSupportedModes() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
			values = append(values, source.UnlockRequired)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
			for _, value := range source.GetUnlockRetries() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		res := source.GetAccessTechnologies()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		res := source.GetBearers()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		return source.GetCarrierConfiguration(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		return source.GetCarrierConfigurationRevision(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		res := source.GetCurrentBands()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		res := source.GetCurrentCapabilities()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		return source.GetCurrentModes(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		return source.GetDevice(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		return source.GetDeviceIdentifier(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		res := source.GetDrivers()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		return source.GetEquipmentIdentifier(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		return source.GetHardwareRevision(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		return source.GetManufacturer(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		return source.GetModel(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		res := source.GetOwnNumbers()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		return source.GetPlugin(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		res := source.GetPorts()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		return source.GetPowerState(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		return source.GetPrimaryPort(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		return source.GetPrimarySimSlot(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		return source.GetRevision(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		res := source.GetSignalQuality()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		return source.GetSim(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		res := source.GetSimSlots()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		return source.GetState(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		return source.GetStateFailedReason(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		res := source.GetSupportedBands()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		res := source.GetSupportedCapabilities()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		res := source.GetSupportedIpFamilies()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		res := source.GetSupportedModes()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		return source.GetUnlockRequired(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		res := source.GetUnlockRetries()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		return ([]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
			item.AccessTechnologies = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
			item.Bearers = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
			item.CarrierConfiguration = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
			item.CarrierConfigurationRevision = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
			item.CurrentBands = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
			item.CurrentCapabilities = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
			item.CurrentModes = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
			item.Device = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
			item.DeviceIdentifier = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
			item.Drivers = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
			item.EquipmentIdentifier = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
			item.HardwareRevision = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
			item.Manufacturer = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
			item.Model = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
			item.OwnNumbers = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
			item.Plugin = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
			item.Ports = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
			item.PowerState = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
			item.PrimaryPort = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
			item.PrimarySimSlot = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
			item.Revision = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
			item.SignalQuality = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
			item.Sim = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
			item.SimSlots = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
			item.State = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
			item.StateFailedReason = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
			item.SupportedBands = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
			item.SupportedCapabilities = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
			item.SupportedIpFamilies = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
			item.SupportedModes = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
			item.UnlockRequired = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
			item.UnlockRetries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) AsSignalQualitySubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		values = append(values, fps.subPath.GetRaw(source.GetSignalQuality())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		if source.GetSignalQuality() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSignalQuality())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
			fps.subPath.ClearValueRaw(item.SignalQuality)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue allows storing values for Generic fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_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 Generic field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Generic' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsAccessTechnologiesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsBearersValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsCarrierConfigurationValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsCarrierConfigurationRevisionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsCurrentBandsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsCurrentCapabilitiesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsCurrentModesValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsDeviceValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsDeviceIdentifierValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsDriversValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsEquipmentIdentifierValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsHardwareRevisionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsManufacturerValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsModelValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsOwnNumbersValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsPluginValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsPortsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsPowerStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsPrimaryPortValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsPrimarySimSlotValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsRevisionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSignalQualityValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSimValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSimSlotsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsStateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsStateFailedReasonValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSupportedBandsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSupportedCapabilitiesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSupportedIpFamiliesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsSupportedModesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsUnlockRequiredValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) AsUnlockRetriesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object Generic
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		(*target).AccessTechnologies = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		(*target).Bearers = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		(*target).CarrierConfiguration = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		(*target).CarrierConfigurationRevision = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		(*target).CurrentBands = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		(*target).CurrentCapabilities = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		(*target).CurrentModes = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		(*target).Device = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		(*target).DeviceIdentifier = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		(*target).Drivers = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		(*target).EquipmentIdentifier = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		(*target).HardwareRevision = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		(*target).Manufacturer = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		(*target).Model = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		(*target).OwnNumbers = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		(*target).Plugin = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		(*target).Ports = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		(*target).PowerState = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		(*target).PrimaryPort = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		(*target).PrimarySimSlot = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		(*target).Revision = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		(*target).SignalQuality = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		(*target).Sim = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		(*target).SimSlots = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		(*target).State = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		(*target).StateFailedReason = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		(*target).SupportedBands = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		(*target).SupportedCapabilities = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		(*target).SupportedIpFamilies = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		(*target).SupportedModes = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		(*target).UnlockRequired = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		(*target).UnlockRetries = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		leftValue := fpv.value.(string)
		rightValue := source.GetCarrierConfiguration()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		leftValue := fpv.value.(string)
		rightValue := source.GetCarrierConfigurationRevision()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		leftValue := fpv.value.(string)
		rightValue := source.GetCurrentModes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		leftValue := fpv.value.(string)
		rightValue := source.GetDevice()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		leftValue := fpv.value.(string)
		rightValue := source.GetDeviceIdentifier()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		leftValue := fpv.value.(string)
		rightValue := source.GetEquipmentIdentifier()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		leftValue := fpv.value.(string)
		rightValue := source.GetHardwareRevision()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		leftValue := fpv.value.(string)
		rightValue := source.GetManufacturer()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		leftValue := fpv.value.(string)
		rightValue := source.GetModel()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		leftValue := fpv.value.(string)
		rightValue := source.GetPlugin()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		leftValue := fpv.value.(string)
		rightValue := source.GetPowerState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		leftValue := fpv.value.(string)
		rightValue := source.GetPrimaryPort()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		leftValue := fpv.value.(string)
		rightValue := source.GetPrimarySimSlot()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		leftValue := fpv.value.(string)
		rightValue := source.GetRevision()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		leftValue := fpv.value.(string)
		rightValue := source.GetSim()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		leftValue := fpv.value.(string)
		rightValue := source.GetState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		leftValue := fpv.value.(string)
		rightValue := source.GetStateFailedReason()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		leftValue := fpv.value.(string)
		rightValue := source.GetUnlockRequired()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue) AsSignalQualityPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue).SetTo(&(*target).SignalQuality)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathValue).CompareWith(source.GetSignalQuality())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue allows storing single item in Path-specific values for Generic according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_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 Generic field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsAccessTechnologiesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsBearersItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsCurrentBandsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsCurrentCapabilitiesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsDriversItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsOwnNumbersItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsPortsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsSimSlotsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsSupportedBandsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsSupportedCapabilitiesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsSupportedIpFamiliesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsSupportedModesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) AsUnlockRetriesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Generic'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_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 DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayItemValue) AsSignalQualityPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Generic'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayItemValue).ContainsValue(source.GetSignalQuality())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues allows storing slice of values for Generic fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_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 Generic field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsAccessTechnologiesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsBearersArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsCarrierConfigurationArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsCarrierConfigurationRevisionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsCurrentBandsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsCurrentCapabilitiesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsCurrentModesArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsDeviceArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsDeviceIdentifierArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsDriversArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsEquipmentIdentifierArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsHardwareRevisionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsManufacturerArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsModelArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsOwnNumbersArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsPluginArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsPortsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsPowerStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsPrimaryPortArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsPrimarySimSlotArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsRevisionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSignalQualityArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSimArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSimSlotsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsStateFailedReasonArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSupportedBandsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSupportedCapabilitiesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSupportedIpFamiliesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsSupportedModesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsUnlockRequiredArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPathArrayOfValues) AsUnlockRetriesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPathArrayOfValues) AsSignalQualityPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath         DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive           DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid              DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus       DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 4
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1             DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 5
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2             DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 6
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid            DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 7
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi             DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 8
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode     DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 9
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName     DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 10
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability     DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 11
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType          DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector = 12
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		return "dbus_path"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		return "active"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		return "eid"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		return "emergency_numbers"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		return "esim_status"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		return "gid1"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		return "gid2"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		return "iccid"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		return "imsi"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		return "operator_code"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		return "operator_name"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		return "removability"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		return "sim_type"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "dbus_path", "dbusPath", "dbus-path":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath}, nil
		case "active":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive}, nil
		case "eid":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid}, nil
		case "emergency_numbers", "emergencyNumbers", "emergency-numbers":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers}, nil
		case "esim_status", "esimStatus", "esim-status":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus}, nil
		case "gid1", "gid_1", "gid-1":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1}, nil
		case "gid2", "gid_2", "gid-2":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2}, nil
		case "iccid":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid}, nil
		case "imsi":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi}, nil
		case "operator_code", "operatorCode", "operator-code":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode}, nil
		case "operator_name", "operatorName", "operator-name":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName}, nil
		case "removability":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability}, nil
		case "sim_type", "simType", "sim-type":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
			values = append(values, source.DbusPath)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
			values = append(values, source.Active)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
			values = append(values, source.Eid)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
			for _, value := range source.GetEmergencyNumbers() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
			values = append(values, source.EsimStatus)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
			values = append(values, source.Gid1)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
			values = append(values, source.Gid2)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
			values = append(values, source.Iccid)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
			values = append(values, source.Imsi)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
			values = append(values, source.OperatorCode)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
			values = append(values, source.OperatorName)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
			values = append(values, source.Removability)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
			values = append(values, source.SimType)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		return source.GetDbusPath(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		return source.GetActive(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		return source.GetEid(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		res := source.GetEmergencyNumbers()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		return source.GetEsimStatus(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		return source.GetGid1(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		return source.GetGid2(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		return source.GetIccid(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		return source.GetImsi(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		return source.GetOperatorCode(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		return source.GetOperatorName(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		return source.GetRemovability(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		return source.GetSimType(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
			item.DbusPath = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
			item.Active = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
			item.Eid = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
			item.EmergencyNumbers = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
			item.EsimStatus = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
			item.Gid1 = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
			item.Gid2 = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
			item.Iccid = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
			item.Imsi = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
			item.OperatorCode = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
			item.OperatorName = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
			item.Removability = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
			item.SimType = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1 ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2 ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability ||
		fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue allows storing values for SimStatus fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_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 SimStatus field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'SimStatus' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsDbusPathValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsActiveValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsEidValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsEmergencyNumbersValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsEsimStatusValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsGid1Value() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsGid2Value() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsIccidValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsImsiValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsOperatorCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsOperatorNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsRemovabilityValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) AsSimTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object SimStatus
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		(*target).DbusPath = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		(*target).Active = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		(*target).Eid = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		(*target).EmergencyNumbers = fpv.value.([]string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		(*target).EsimStatus = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		(*target).Gid1 = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		(*target).Gid2 = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		(*target).Iccid = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		(*target).Imsi = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		(*target).OperatorCode = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		(*target).OperatorName = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		(*target).Removability = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		(*target).SimType = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		leftValue := fpv.value.(string)
		rightValue := source.GetDbusPath()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		leftValue := fpv.value.(string)
		rightValue := source.GetActive()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		leftValue := fpv.value.(string)
		rightValue := source.GetEid()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		leftValue := fpv.value.(string)
		rightValue := source.GetEsimStatus()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		leftValue := fpv.value.(string)
		rightValue := source.GetGid1()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		leftValue := fpv.value.(string)
		rightValue := source.GetGid2()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		leftValue := fpv.value.(string)
		rightValue := source.GetIccid()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		leftValue := fpv.value.(string)
		rightValue := source.GetImsi()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatorCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatorName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		leftValue := fpv.value.(string)
		rightValue := source.GetRemovability()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		leftValue := fpv.value.(string)
		rightValue := source.GetSimType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue allows storing single item in Path-specific values for SimStatus according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_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 SimStatus field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue) AsEmergencyNumbersItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

// Contains returns a boolean indicating if value that is being held is present in given 'SimStatus'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_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
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues allows storing slice of values for SimStatus fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_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 SimStatus field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsDbusPathArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsActiveArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsEidArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsEmergencyNumbersArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsEsimStatusArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsGid1ArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsGid2ArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsIccidArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsImsiArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsOperatorCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsOperatorNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsRemovabilityArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPathArrayOfValues) AsSimTypeArrayOfValues() ([]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 DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)

	// Those methods build corresponding DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp  DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector = 0
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma      DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector = 1
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath  DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector = 2
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric   DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector = 3
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector = 4
)

func (s DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return "three_g_pp"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return "cdma"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		return "dbus_path"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return "generic"
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return "sim_status"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "three_g_pp", "threeGPp", "three-g-pp":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp}, nil
		case "cdma":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma}, nil
		case "dbus_path", "dbusPath", "dbus-path":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath}, nil
		case "generic":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric}, nil
		case "sim_status", "simStatus", "sim-status":
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus}, nil
		}
	} else {
		switch fp[0] {
		case "three_g_pp", "threeGPp", "three-g-pp":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp, subPath: subpath}, nil
			}
		case "cdma":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma, subPath: subpath}, nil
			}
		case "generic":
			if subpath, err := BuildDeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric, subPath: subpath}, nil
			}
		case "sim_status", "simStatus", "sim-status":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)", fp)
			}
			return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem", fp)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath(rawField string) (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath(rawField string) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
			if source.ThreeGPp != nil {
				values = append(values, source.ThreeGPp)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
			if source.Cdma != nil {
				values = append(values, source.Cdma)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
			values = append(values, source.DbusPath)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
			if source.Generic != nil {
				values = append(values, source.Generic)
			}
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
			if source.SimStatus != nil {
				values = append(values, source.SimStatus)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		res := source.GetThreeGPp()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		res := source.GetCdma()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		return source.GetDbusPath(), source != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		res := source.GetGeneric()
		return res, res != nil
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		res := source.GetSimStatus()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		return ""
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)(nil)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return (map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
			item.ThreeGPp = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
			item.Cdma = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
			item.DbusPath = ""
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
			item.Generic = nil
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
			item.SimStatus = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, value: value.(map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath: *fp, values: values.([]map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// FieldPath for map type with additional Key information
type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap struct {
	key      string
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap)(nil)

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector {
	return fpm.selector
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) Key() string {
	return fpm.key
}

// String returns path representation in proto convention
func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_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 *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

// Get returns all values pointed by selected field map key from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem
func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (values []interface{}) {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		if value, ok := source.GetSimStatus()[fpm.key]; ok {
			values = append(values, value)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
	}
	return
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) GetRaw(source proto.Message) []interface{} {
	return fpm.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// GetSingle returns value by selected field map key from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem
func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (interface{}, bool) {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		res, ok := source.GetSimStatus()[fpm.key]
		return res, ok
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpm.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// GetDefault returns a default value of the field type
func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		var v *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if item != nil {
		switch fpm.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
			delete(item.SimStatus, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
		}
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// IsLeaf - whether field path is holds simple value
func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) IsLeaf() bool {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fpm}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap: *fpm, value: value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fpm.WithIValue(value)
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues {
	switch fpm.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapArrayOfValues{DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap: *fpm, values: values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpm.selector))
	}
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fpm.WithIArrayOfValues(values)
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue {
	panic("Cannot create array item value from map fieldpath")
}

func (fpm *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fpm.WithIArrayItemValue(value)
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath struct {
	selector DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath)(nil)

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) Selector() DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelector {
	return fps.selector
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) AsThreeGPpSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) AsCdmaSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPath)
	return res, ok
}
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) AsGenericSubPath() (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath, bool) {
	res, ok := fps.subPath.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) Get(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (values []interface{}) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		values = append(values, fps.subPath.GetRaw(source.GetThreeGPp())...)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		values = append(values, fps.subPath.GetRaw(source.GetCdma())...)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		values = append(values, fps.subPath.GetRaw(source.GetGeneric())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fps.selector))
	}
	return
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// GetSingle returns value of selected field from source Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (interface{}, bool) {
	switch fps.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		if source.GetThreeGPp() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetThreeGPp())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		if source.GetCdma() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetCdma())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		if source.GetGeneric() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetGeneric())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fps.selector))
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// GetDefault returns a default value of the field type
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) ClearValue(item *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if item != nil {
		switch fps.selector {
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
			fps.subPath.ClearValueRaw(item.ThreeGPp)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
			fps.subPath.ClearValueRaw(item.Cdma)
		case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
			fps.subPath.ClearValueRaw(item.Generic)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fps.selector))
		}
	}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// IsLeaf - whether field path is holds simple value
func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) WithIValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue {
	return &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue allows storing values for Modem fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue interface {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	CompareWith(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_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 Modem field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Modem' as interface{}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) AsThreeGPpValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) AsCdmaValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) AsDbusPathValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) AsGenericValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic, bool) {
	res, ok := fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) AsSimStatusValue() (map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus, bool) {
	res, ok := fpv.value.(map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	return res, ok
}

// SetTo stores value for selected field for object Modem
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		(*target).ThreeGPp = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		(*target).Cdma = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		(*target).DbusPath = fpv.value.(string)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		(*target).Generic = fpv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		(*target).SimStatus = fpv.value.(map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem'.
func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		leftValue := fpv.value.(string)
		rightValue := source.GetDbusPath()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return 0, false
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in Modem as interface{}
func (fpmv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue) AsSimStatusElementValue() (*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus, bool) {
	res, ok := fpmv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	return res, ok
}

// SetTo stores value for selected field in Modem
func (fpmv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	}
	switch fpmv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		if (*target).SimStatus == nil {
			(*target).SimStatus = make(map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
		}
		(*target).SimStatus[fpmv.key] = fpmv.value.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpmv.selector))
	}
}

func (fpmv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	fpmv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue' with the value under path in 'Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem'.
func (fpmv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (int, bool) {
	switch fpmv.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpmv.selector))
	}
}

func (fpmv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpmv.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue)(nil)

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) AsThreeGPpPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) AsCdmaPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue)
	return res, ok
}
func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) AsGenericPathValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue)
	return res, ok
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) SetTo(target **Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	}
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue).SetTo(&(*target).ThreeGPp)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue).SetTo(&(*target).Cdma)
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue).SetTo(&(*target).Generic)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
	fpvs.SetTo(&typedObject)
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) CompareWith(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (int, bool) {
	switch fpvs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathValue).CompareWith(source.GetThreeGPp())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathValue).CompareWith(source.GetCdma())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return fpvs.subPathValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathValue).CompareWith(source.GetGeneric())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpvs.Selector()))
	}
}

func (fpvs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue allows storing single item in Path-specific values for Modem according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) bool
}

// ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_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 Modem field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem as interface{}
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Modem'
func (fpaiv *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) bool {
	slice := fpaiv.DeviceStatusDeviceInfoHardwareInformationModemStatusModem_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 DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue) AsThreeGPpPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue) AsCdmaPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue) AsGenericPathItemValue() (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Modem'
func (fpaivs *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) bool {
	switch fpaivs.Selector() {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayItemValue).ContainsValue(source.GetThreeGPp())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayItemValue).ContainsValue(source.GetCdma())
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		return fpaivs.subPathItemValue.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayItemValue).ContainsValue(source.GetGeneric())
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem: %d", fpaivs.Selector()))
	}
}

// DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues allows storing slice of values for Modem fields according to their type
type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath
}

func ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_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 Modem field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric:
		for _, v := range fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		for _, v := range fpaov.values.([]map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues) AsThreeGPpArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues) AsCdmaArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues) AsDbusPathArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues) AsGenericArrayOfValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic, bool) {
	res, ok := fpaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPathArrayOfValues) AsSimStatusArrayOfValues() ([]map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus, bool) {
	res, ok := fpaov.values.([]map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMap
	values interface{}
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapArrayOfValues)(nil)

func (fpmaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus:
		for _, v := range fpmaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathMapArrayOfValues) AsSimStatusArrayOfElementValues() ([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus, bool) {
	res, ok := fpmaov.values.([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
	return res, ok
}

type DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues struct {
	DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues)(nil)

func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues) AsThreeGPpPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues) AsCdmaPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPathArrayOfValues) AsGenericPathArrayOfValues() (DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_NetworkInterface_ASInfo)

	// Those methods build corresponding DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn     DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector = 0
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName    DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector = 1
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain  DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector = 2
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes  DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector = 3
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector = 4
)

func (s DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		return "asn"
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		return "domain"
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		return "routes"
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		return "asn_type"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_NetworkInterface_ASInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "asn":
			return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn}, nil
		case "name":
			return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName}, nil
		case "domain":
			return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain}, nil
		case "routes":
			return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes}, nil
		case "asn_type", "asnType", "asn-type":
			return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_NetworkInterface_ASInfo", fp)
}

func ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath(rawField string) (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath(rawField string) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector
}

var _ DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath = (*DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) Selector() DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_NetworkInterface_ASInfo
func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
			values = append(values, source.Asn)
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
			values = append(values, source.Domain)
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
			for _, value := range source.GetRoutes() {
				values = append(values, value)
			}
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
			values = append(values, source.AsnType)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_NetworkInterface_ASInfo
func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		return source.GetAsn(), source != nil
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		return source.GetDomain(), source != nil
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		res := source.GetRoutes()
		return res, res != nil
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		return source.GetAsnType(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		return ""
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		return ""
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		return ([]string)(nil)
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_NetworkInterface_ASInfo) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
			item.Asn = ""
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
			item.Domain = ""
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
			item.Routes = nil
		case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
			item.AsnType = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, value: value.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, values: values.([][]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		return &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue{DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue allows storing values for ASInfo fields according to their type
type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue interface {
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_NetworkInterface_ASInfo)
	CompareWith(*Device_Status_DeviceInfo_NetworkInterface_ASInfo) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_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 ASInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathValue = (*DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ASInfo' as interface{}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) AsAsnValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) AsDomainValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) AsRoutesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) AsAsnTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object ASInfo
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_NetworkInterface_ASInfo) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_NetworkInterface_ASInfo)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		(*target).Asn = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		(*target).Domain = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		(*target).Routes = fpv.value.([]string)
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		(*target).AsnType = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_NetworkInterface_ASInfo'.
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		leftValue := fpv.value.(string)
		rightValue := source.GetAsn()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		leftValue := fpv.value.(string)
		rightValue := source.GetDomain()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		return 0, false
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		leftValue := fpv.value.(string)
		rightValue := source.GetAsnType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_ASInfo: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

// DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue allows storing single item in Path-specific values for ASInfo according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_NetworkInterface_ASInfo) bool
}

// ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_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 ASInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_NetworkInterface_ASInfo as interface{}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue) AsRoutesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ASInfo'
func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) bool {
	slice := fpaiv.DeviceStatusDeviceInfoNetworkInterfaceASInfo_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
}

// DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues allows storing slice of values for ASInfo fields according to their type
type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPath
}

func ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_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 ASInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues) AsAsnArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues) AsDomainArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues) AsRoutesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPathArrayOfValues) AsAsnTypeArrayOfValues() ([]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 DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector
	Get(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) []interface{}
	GetSingle(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) (interface{}, bool)
	ClearValue(item *Device_Status_DeviceInfo_NetworkInterface_Carrier)

	// Those methods build corresponding DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue
	WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue
}

type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector int32

const (
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName              DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector = 0
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector = 1
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector = 2
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode  DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector = 3
)

func (s DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector) String() string {
	switch s {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		return "name"
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		return "mobile_country_code"
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		return "mobile_network_code"
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		return "location_area_code"
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", s))
	}
}

func BuildDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath(fp gotenobject.RawFieldPath) (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Device_Status_DeviceInfo_NetworkInterface_Carrier")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName}, nil
		case "mobile_country_code", "mobileCountryCode", "mobile-country-code":
			return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode}, nil
		case "mobile_network_code", "mobileNetworkCode", "mobile-network-code":
			return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode}, nil
		case "location_area_code", "locationAreaCode", "location-area-code":
			return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Device_Status_DeviceInfo_NetworkInterface_Carrier", fp)
}

func ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath(rawField string) (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath(fp)
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath(rawField string) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath struct {
	selector DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector
}

var _ DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath = (*DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath)(nil)

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) Selector() DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source Device_Status_DeviceInfo_NetworkInterface_Carrier
func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) Get(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
			values = append(values, source.Name)
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
			values = append(values, source.MobileCountryCode)
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
			values = append(values, source.MobileNetworkCode)
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
			values = append(values, source.LocationAreaCode)
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
		}
	}
	return
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}

// GetSingle returns value pointed by specific field of from source Device_Status_DeviceInfo_NetworkInterface_Carrier
func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) GetSingle(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) (interface{}, bool) {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		return source.GetName(), source != nil
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		return source.GetMobileCountryCode(), source != nil
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		return source.GetMobileNetworkCode(), source != nil
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		return source.GetLocationAreaCode(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}

// GetDefault returns a default value of the field type
func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		return ""
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		return ""
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		return ""
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) ClearValue(item *Device_Status_DeviceInfo_NetworkInterface_Carrier) {
	if item != nil {
		switch fp.selector {
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
			item.Name = ""
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
			item.MobileCountryCode = ""
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
			item.MobileNetworkCode = ""
		case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
			item.LocationAreaCode = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
		}
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode ||
		fp.selector == DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) WithIValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue {
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, value: value.(string)}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues {
	fpaov := &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, values: values.([]string)}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		return &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues{DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fp.selector))
	}
}

func (fp *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue allows storing values for Carrier fields according to their type
type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue interface {
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Device_Status_DeviceInfo_NetworkInterface_Carrier)
	CompareWith(*Device_Status_DeviceInfo_NetworkInterface_Carrier) (cmp int, comparable bool)
}

func ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue(pathStr, valueStr string) (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_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 Carrier field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue), nil
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue(pathStr, valueStr string) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue {
	fpv, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue struct {
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathValue = (*DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Carrier' as interface{}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) AsMobileCountryCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) AsMobileNetworkCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) AsLocationAreaCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Carrier
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) SetTo(target **Device_Status_DeviceInfo_NetworkInterface_Carrier) {
	if *target == nil {
		*target = new(Device_Status_DeviceInfo_NetworkInterface_Carrier)
	}
	switch fpv.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		(*target).MobileCountryCode = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		(*target).MobileNetworkCode = fpv.value.(string)
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		(*target).LocationAreaCode = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*Device_Status_DeviceInfo_NetworkInterface_Carrier)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue' with the value under path in 'Device_Status_DeviceInfo_NetworkInterface_Carrier'.
func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) CompareWith(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) (int, bool) {
	switch fpv.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetMobileCountryCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetMobileNetworkCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetLocationAreaCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Device_Status_DeviceInfo_NetworkInterface_Carrier: %d", fpv.selector))
	}
}

func (fpv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}

// DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue allows storing single item in Path-specific values for Carrier according to their type
// Present only for array (repeated) types.
type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath
	ContainsValue(*Device_Status_DeviceInfo_NetworkInterface_Carrier) bool
}

// ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue(pathStr, valueStr string) (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue, error) {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_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 Carrier field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue), nil
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue(pathStr, valueStr string) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue {
	fpaiv, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayItemValue struct {
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath
	value interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayItemValue = (*DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Device_Status_DeviceInfo_NetworkInterface_Carrier as interface{}
func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayItemValue) GetSingle(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Carrier'
func (fpaiv *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayItemValue) ContainsValue(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) bool {
	slice := fpaiv.DeviceStatusDeviceInfoNetworkInterfaceCarrier_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
}

// DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues allows storing slice of values for Carrier fields according to their type
type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPath
}

func ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues(pathStr, valuesStr string) (DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues, error) {
	fp, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_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 Carrier field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues), nil
}

func MustParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues(pathStr, valuesStr string) DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues {
	fpaov, err := ParseDeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues struct {
	DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath
	values interface{}
}

var _ DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathArrayOfValues = (*DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues) AsMobileCountryCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues) AsMobileNetworkCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPathArrayOfValues) AsLocationAreaCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}