github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/alert/alert.pb.fieldpathbuilder.go

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

package alert

// proto imports
import (
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	document "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/document"
	log_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition"
	log_condition_template "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition_template"
	notification_channel "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/notification_channel"
	policy "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy"
	policy_template "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy_template"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	api "github.com/cloudwan/edgelq-sdk/common/api"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	logging_bucket "github.com/cloudwan/edgelq-sdk/logging/resources/v1/bucket"
	logging_common "github.com/cloudwan/edgelq-sdk/logging/resources/v1/common"
	logging_log "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log"
	logging_log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log_descriptor"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	monitoring_metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/metric_descriptor"
	monitoring_monitored_resource_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/monitored_resource_descriptor"
	monitoring_project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	monitoring_time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/time_serie"
	meta_common "github.com/cloudwan/goten-sdk/meta-service/resources/v1/common"
	meta_resource "github.com/cloudwan/goten-sdk/meta-service/resources/v1/resource"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// make sure we're using proto imports
var (
	_ = &document.Document{}
	_ = &log_condition.LogCondition{}
	_ = &log_condition_template.LogConditionTemplate{}
	_ = &notification_channel.NotificationChannel{}
	_ = &policy.Policy{}
	_ = &policy_template.PolicyTemplate{}
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = api.LaunchStage(0)
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &logging_bucket.Bucket{}
	_ = &logging_common.LabelDescriptor{}
	_ = &logging_log.Log{}
	_ = &logging_log_descriptor.LogDescriptor{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &monitoring_metric_descriptor.MetricDescriptor{}
	_ = &monitoring_monitored_resource_descriptor.MonitoredResourceDescriptor{}
	_ = &monitoring_project.Project{}
	_ = &monitoring_time_serie.Point{}
	_ = &anypb.Any{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &structpb.Struct{}
	_ = &timestamppb.Timestamp{}
	_ = &meta_common.LabelledDomain{}
	_ = &meta_resource.Resource{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type AlertFieldPathBuilder struct{}

func NewAlertFieldPathBuilder() AlertFieldPathBuilder {
	return AlertFieldPathBuilder{}
}
func (AlertFieldPathBuilder) Name() AlertPathSelectorName {
	return AlertPathSelectorName{}
}
func (AlertFieldPathBuilder) Metadata() AlertPathSelectorMetadata {
	return AlertPathSelectorMetadata{}
}
func (AlertFieldPathBuilder) DisplayName() AlertPathSelectorDisplayName {
	return AlertPathSelectorDisplayName{}
}
func (AlertFieldPathBuilder) AlertingResource() AlertPathSelectorAlertingResource {
	return AlertPathSelectorAlertingResource{}
}
func (AlertFieldPathBuilder) TsInfo() AlertPathSelectorTsInfo {
	return AlertPathSelectorTsInfo{}
}
func (AlertFieldPathBuilder) LogInfo() AlertPathSelectorLogInfo {
	return AlertPathSelectorLogInfo{}
}
func (AlertFieldPathBuilder) State() AlertPathSelectorState {
	return AlertPathSelectorState{}
}
func (AlertFieldPathBuilder) Internal() AlertPathSelectorInternal {
	return AlertPathSelectorInternal{}
}

type AlertPathSelectorName struct{}

func (AlertPathSelectorName) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorName}
}

func (s AlertPathSelectorName) WithValue(value *Name) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorName) WithArrayOfValues(values []*Name) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

type AlertPathSelectorMetadata struct{}

func (AlertPathSelectorMetadata) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorMetadata}
}

func (s AlertPathSelectorMetadata) WithValue(value *meta.Meta) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorMetadata) WithArrayOfValues(values []*meta.Meta) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

func (AlertPathSelectorMetadata) WithSubPath(subPath meta.Meta_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorMetadata, subPath: subPath}
}

func (s AlertPathSelectorMetadata) WithSubValue(subPathValue meta.Meta_FieldPathValue) *Alert_FieldSubPathValue {
	return &Alert_FieldSubPathValue{Alert_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues meta.Meta_FieldPathArrayOfValues) *Alert_FieldSubPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{Alert_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue meta.Meta_FieldPathArrayItemValue) *Alert_FieldSubPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{Alert_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertPathSelectorMetadata) CreateTime() AlertPathSelectorMetadataCreateTime {
	return AlertPathSelectorMetadataCreateTime{}
}

func (AlertPathSelectorMetadata) UpdateTime() AlertPathSelectorMetadataUpdateTime {
	return AlertPathSelectorMetadataUpdateTime{}
}

func (AlertPathSelectorMetadata) DeleteTime() AlertPathSelectorMetadataDeleteTime {
	return AlertPathSelectorMetadataDeleteTime{}
}

func (AlertPathSelectorMetadata) Uuid() AlertPathSelectorMetadataUuid {
	return AlertPathSelectorMetadataUuid{}
}

func (AlertPathSelectorMetadata) Tags() AlertPathSelectorMetadataTags {
	return AlertPathSelectorMetadataTags{}
}

func (AlertPathSelectorMetadata) Labels() AlertPathSelectorMetadataLabels {
	return AlertPathSelectorMetadataLabels{}
}

func (AlertPathSelectorMetadata) Annotations() AlertPathSelectorMetadataAnnotations {
	return AlertPathSelectorMetadataAnnotations{}
}

func (AlertPathSelectorMetadata) Generation() AlertPathSelectorMetadataGeneration {
	return AlertPathSelectorMetadataGeneration{}
}

func (AlertPathSelectorMetadata) ResourceVersion() AlertPathSelectorMetadataResourceVersion {
	return AlertPathSelectorMetadataResourceVersion{}
}

func (AlertPathSelectorMetadata) OwnerReferences() AlertPathSelectorMetadataOwnerReferences {
	return AlertPathSelectorMetadataOwnerReferences{}
}

func (AlertPathSelectorMetadata) Shards() AlertPathSelectorMetadataShards {
	return AlertPathSelectorMetadataShards{}
}

func (AlertPathSelectorMetadata) Syncing() AlertPathSelectorMetadataSyncing {
	return AlertPathSelectorMetadataSyncing{}
}

func (AlertPathSelectorMetadata) Lifecycle() AlertPathSelectorMetadataLifecycle {
	return AlertPathSelectorMetadataLifecycle{}
}

func (AlertPathSelectorMetadata) Services() AlertPathSelectorMetadataServices {
	return AlertPathSelectorMetadataServices{}
}

type AlertPathSelectorMetadataCreateTime struct{}

func (AlertPathSelectorMetadataCreateTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataCreateTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataCreateTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataUpdateTime struct{}

func (AlertPathSelectorMetadataUpdateTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataUpdateTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataUpdateTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataDeleteTime struct{}

func (AlertPathSelectorMetadataDeleteTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataDeleteTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataDeleteTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataUuid struct{}

func (AlertPathSelectorMetadataUuid) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataUuid) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataUuid) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataTags struct{}

func (AlertPathSelectorMetadataTags) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataTags) WithValue(value []string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataTags) WithArrayOfValues(values [][]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorMetadataTags) WithItemValue(value string) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorMetadataLabels struct{}

func (AlertPathSelectorMetadataLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataLabels) WithValue(value map[string]string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataLabels) WithArrayOfValues(values []map[string]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorMetadataLabels) WithKey(key string) AlertMapPathSelectorMetadataLabels {
	return AlertMapPathSelectorMetadataLabels{key: key}
}

type AlertMapPathSelectorMetadataLabels struct {
	key string
}

func (s AlertMapPathSelectorMetadataLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s AlertMapPathSelectorMetadataLabels) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertMapPathSelectorMetadataLabels) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataAnnotations struct{}

func (AlertPathSelectorMetadataAnnotations) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataAnnotations) WithValue(value map[string]string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataAnnotations) WithArrayOfValues(values []map[string]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorMetadataAnnotations) WithKey(key string) AlertMapPathSelectorMetadataAnnotations {
	return AlertMapPathSelectorMetadataAnnotations{key: key}
}

type AlertMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s AlertMapPathSelectorMetadataAnnotations) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s AlertMapPathSelectorMetadataAnnotations) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertMapPathSelectorMetadataAnnotations) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataGeneration struct{}

func (AlertPathSelectorMetadataGeneration) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataGeneration) WithValue(value int64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataGeneration) WithArrayOfValues(values []int64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataResourceVersion struct{}

func (AlertPathSelectorMetadataResourceVersion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataResourceVersion) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataResourceVersion) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferences struct{}

func (AlertPathSelectorMetadataOwnerReferences) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferences) WithValue(value []*meta.OwnerReference) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferences) WithArrayOfValues(values [][]*meta.OwnerReference) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorMetadataOwnerReferences) WithItemValue(value *meta.OwnerReference) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

func (AlertPathSelectorMetadataOwnerReferences) Kind() AlertPathSelectorMetadataOwnerReferencesKind {
	return AlertPathSelectorMetadataOwnerReferencesKind{}
}

func (AlertPathSelectorMetadataOwnerReferences) Version() AlertPathSelectorMetadataOwnerReferencesVersion {
	return AlertPathSelectorMetadataOwnerReferencesVersion{}
}

func (AlertPathSelectorMetadataOwnerReferences) Name() AlertPathSelectorMetadataOwnerReferencesName {
	return AlertPathSelectorMetadataOwnerReferencesName{}
}

func (AlertPathSelectorMetadataOwnerReferences) Region() AlertPathSelectorMetadataOwnerReferencesRegion {
	return AlertPathSelectorMetadataOwnerReferencesRegion{}
}

func (AlertPathSelectorMetadataOwnerReferences) Controller() AlertPathSelectorMetadataOwnerReferencesController {
	return AlertPathSelectorMetadataOwnerReferencesController{}
}

func (AlertPathSelectorMetadataOwnerReferences) RequiresOwnerReference() AlertPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return AlertPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

func (AlertPathSelectorMetadataOwnerReferences) UnsetOnDelete() AlertPathSelectorMetadataOwnerReferencesUnsetOnDelete {
	return AlertPathSelectorMetadataOwnerReferencesUnsetOnDelete{}
}

type AlertPathSelectorMetadataOwnerReferencesKind struct{}

func (AlertPathSelectorMetadataOwnerReferencesKind) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesKind) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferencesVersion struct{}

func (AlertPathSelectorMetadataOwnerReferencesVersion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesVersion) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferencesName struct{}

func (AlertPathSelectorMetadataOwnerReferencesName) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesName) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesName) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferencesRegion struct{}

func (AlertPathSelectorMetadataOwnerReferencesRegion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesRegion) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferencesController struct{}

func (AlertPathSelectorMetadataOwnerReferencesController) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesController) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (AlertPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataOwnerReferencesUnsetOnDelete struct{}

func (AlertPathSelectorMetadataOwnerReferencesUnsetOnDelete) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().UnsetOnDelete().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataShards struct{}

func (AlertPathSelectorMetadataShards) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataShards) WithValue(value map[string]int64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataShards) WithArrayOfValues(values []map[string]int64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorMetadataShards) WithKey(key string) AlertMapPathSelectorMetadataShards {
	return AlertMapPathSelectorMetadataShards{key: key}
}

type AlertMapPathSelectorMetadataShards struct {
	key string
}

func (s AlertMapPathSelectorMetadataShards) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s AlertMapPathSelectorMetadataShards) WithValue(value int64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertMapPathSelectorMetadataShards) WithArrayOfValues(values []int64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataSyncing struct{}

func (AlertPathSelectorMetadataSyncing) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataSyncing) WithValue(value *meta.SyncingMeta) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataSyncing) WithArrayOfValues(values []*meta.SyncingMeta) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorMetadataSyncing) OwningRegion() AlertPathSelectorMetadataSyncingOwningRegion {
	return AlertPathSelectorMetadataSyncingOwningRegion{}
}

func (AlertPathSelectorMetadataSyncing) Regions() AlertPathSelectorMetadataSyncingRegions {
	return AlertPathSelectorMetadataSyncingRegions{}
}

type AlertPathSelectorMetadataSyncingOwningRegion struct{}

func (AlertPathSelectorMetadataSyncingOwningRegion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataSyncingOwningRegion) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataSyncingRegions struct{}

func (AlertPathSelectorMetadataSyncingRegions) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataSyncingRegions) WithValue(value []string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataSyncingRegions) WithArrayOfValues(values [][]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorMetadataSyncingRegions) WithItemValue(value string) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorMetadataLifecycle struct{}

func (AlertPathSelectorMetadataLifecycle) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataLifecycle) WithValue(value *meta.Lifecycle) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataLifecycle) WithArrayOfValues(values []*meta.Lifecycle) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorMetadataLifecycle) State() AlertPathSelectorMetadataLifecycleState {
	return AlertPathSelectorMetadataLifecycleState{}
}

func (AlertPathSelectorMetadataLifecycle) BlockDeletion() AlertPathSelectorMetadataLifecycleBlockDeletion {
	return AlertPathSelectorMetadataLifecycleBlockDeletion{}
}

type AlertPathSelectorMetadataLifecycleState struct{}

func (AlertPathSelectorMetadataLifecycleState) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataLifecycleState) WithValue(value meta.Lifecycle_State) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataLifecycleState) WithArrayOfValues(values []meta.Lifecycle_State) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataLifecycleBlockDeletion struct{}

func (AlertPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataLifecycleBlockDeletion) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataServices struct{}

func (AlertPathSelectorMetadataServices) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataServices) WithArrayOfValues(values []*meta.ServicesInfo) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorMetadataServices) OwningService() AlertPathSelectorMetadataServicesOwningService {
	return AlertPathSelectorMetadataServicesOwningService{}
}

func (AlertPathSelectorMetadataServices) AllowedServices() AlertPathSelectorMetadataServicesAllowedServices {
	return AlertPathSelectorMetadataServicesAllowedServices{}
}

type AlertPathSelectorMetadataServicesOwningService struct{}

func (AlertPathSelectorMetadataServicesOwningService) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().OwningService().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataServicesOwningService) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataServicesOwningService) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorMetadataServicesAllowedServices struct{}

func (AlertPathSelectorMetadataServicesAllowedServices) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().AllowedServices().FieldPath(),
	}
}

func (s AlertPathSelectorMetadataServicesAllowedServices) WithValue(value []string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorMetadataServicesAllowedServices) WithArrayOfValues(values [][]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorDisplayName struct{}

func (AlertPathSelectorDisplayName) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorDisplayName}
}

func (s AlertPathSelectorDisplayName) WithValue(value string) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorDisplayName) WithArrayOfValues(values []string) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

type AlertPathSelectorAlertingResource struct{}

func (AlertPathSelectorAlertingResource) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorAlertingResource}
}

func (s AlertPathSelectorAlertingResource) WithValue(value *meta.OwnerReference) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorAlertingResource) WithArrayOfValues(values []*meta.OwnerReference) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

func (AlertPathSelectorAlertingResource) WithSubPath(subPath meta.OwnerReference_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorAlertingResource, subPath: subPath}
}

func (s AlertPathSelectorAlertingResource) WithSubValue(subPathValue meta.OwnerReference_FieldPathValue) *Alert_FieldSubPathValue {
	return &Alert_FieldSubPathValue{Alert_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertPathSelectorAlertingResource) WithSubArrayOfValues(subPathArrayOfValues meta.OwnerReference_FieldPathArrayOfValues) *Alert_FieldSubPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{Alert_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertPathSelectorAlertingResource) WithSubArrayItemValue(subPathArrayItemValue meta.OwnerReference_FieldPathArrayItemValue) *Alert_FieldSubPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{Alert_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertPathSelectorAlertingResource) Kind() AlertPathSelectorAlertingResourceKind {
	return AlertPathSelectorAlertingResourceKind{}
}

func (AlertPathSelectorAlertingResource) Version() AlertPathSelectorAlertingResourceVersion {
	return AlertPathSelectorAlertingResourceVersion{}
}

func (AlertPathSelectorAlertingResource) Name() AlertPathSelectorAlertingResourceName {
	return AlertPathSelectorAlertingResourceName{}
}

func (AlertPathSelectorAlertingResource) Region() AlertPathSelectorAlertingResourceRegion {
	return AlertPathSelectorAlertingResourceRegion{}
}

func (AlertPathSelectorAlertingResource) Controller() AlertPathSelectorAlertingResourceController {
	return AlertPathSelectorAlertingResourceController{}
}

func (AlertPathSelectorAlertingResource) RequiresOwnerReference() AlertPathSelectorAlertingResourceRequiresOwnerReference {
	return AlertPathSelectorAlertingResourceRequiresOwnerReference{}
}

func (AlertPathSelectorAlertingResource) UnsetOnDelete() AlertPathSelectorAlertingResourceUnsetOnDelete {
	return AlertPathSelectorAlertingResourceUnsetOnDelete{}
}

type AlertPathSelectorAlertingResourceKind struct{}

func (AlertPathSelectorAlertingResourceKind) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Kind().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceKind) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceKind) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorAlertingResourceVersion struct{}

func (AlertPathSelectorAlertingResourceVersion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Version().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceVersion) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceVersion) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorAlertingResourceName struct{}

func (AlertPathSelectorAlertingResourceName) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Name().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceName) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceName) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorAlertingResourceRegion struct{}

func (AlertPathSelectorAlertingResourceRegion) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Region().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceRegion) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceRegion) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorAlertingResourceController struct{}

func (AlertPathSelectorAlertingResourceController) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Controller().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceController) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceController) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorAlertingResourceRequiresOwnerReference struct{}

func (AlertPathSelectorAlertingResourceRequiresOwnerReference) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().RequiresOwnerReference().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceRequiresOwnerReference) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceRequiresOwnerReference) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorAlertingResourceUnsetOnDelete struct{}

func (AlertPathSelectorAlertingResourceUnsetOnDelete) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().UnsetOnDelete().FieldPath(),
	}
}

func (s AlertPathSelectorAlertingResourceUnsetOnDelete) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorAlertingResourceUnsetOnDelete) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfo struct{}

func (AlertPathSelectorTsInfo) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorTsInfo}
}

func (s AlertPathSelectorTsInfo) WithValue(value *Alert_TsInfo) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorTsInfo) WithArrayOfValues(values []*Alert_TsInfo) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

func (AlertPathSelectorTsInfo) WithSubPath(subPath AlertTsInfo_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorTsInfo, subPath: subPath}
}

func (s AlertPathSelectorTsInfo) WithSubValue(subPathValue AlertTsInfo_FieldPathValue) *Alert_FieldSubPathValue {
	return &Alert_FieldSubPathValue{Alert_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertPathSelectorTsInfo) WithSubArrayOfValues(subPathArrayOfValues AlertTsInfo_FieldPathArrayOfValues) *Alert_FieldSubPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{Alert_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertPathSelectorTsInfo) WithSubArrayItemValue(subPathArrayItemValue AlertTsInfo_FieldPathArrayItemValue) *Alert_FieldSubPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{Alert_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertPathSelectorTsInfo) Type() AlertPathSelectorTsInfoType {
	return AlertPathSelectorTsInfoType{}
}

func (AlertPathSelectorTsInfo) AnomalyWindowSize() AlertPathSelectorTsInfoAnomalyWindowSize {
	return AlertPathSelectorTsInfoAnomalyWindowSize{}
}

func (AlertPathSelectorTsInfo) CommonKey() AlertPathSelectorTsInfoCommonKey {
	return AlertPathSelectorTsInfoCommonKey{}
}

func (AlertPathSelectorTsInfo) MetricTypes() AlertPathSelectorTsInfoMetricTypes {
	return AlertPathSelectorTsInfoMetricTypes{}
}

func (AlertPathSelectorTsInfo) ResourceTypes() AlertPathSelectorTsInfoResourceTypes {
	return AlertPathSelectorTsInfoResourceTypes{}
}

func (AlertPathSelectorTsInfo) CommonMetricLabels() AlertPathSelectorTsInfoCommonMetricLabels {
	return AlertPathSelectorTsInfoCommonMetricLabels{}
}

func (AlertPathSelectorTsInfo) CommonResourceLabels() AlertPathSelectorTsInfoCommonResourceLabels {
	return AlertPathSelectorTsInfoCommonResourceLabels{}
}

func (AlertPathSelectorTsInfo) TimeSeries() AlertPathSelectorTsInfoTimeSeries {
	return AlertPathSelectorTsInfoTimeSeries{}
}

type AlertPathSelectorTsInfoType struct{}

func (AlertPathSelectorTsInfoType) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().Type().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoType) WithValue(value Alert_TsInfo_Type) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoType) WithArrayOfValues(values []Alert_TsInfo_Type) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoAnomalyWindowSize struct{}

func (AlertPathSelectorTsInfoAnomalyWindowSize) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().AnomalyWindowSize().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoAnomalyWindowSize) WithValue(value *durationpb.Duration) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoAnomalyWindowSize) WithArrayOfValues(values []*durationpb.Duration) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoCommonKey struct{}

func (AlertPathSelectorTsInfoCommonKey) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().CommonKey().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoCommonKey) WithValue(value []byte) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoCommonKey) WithArrayOfValues(values [][]byte) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoMetricTypes struct{}

func (AlertPathSelectorTsInfoMetricTypes) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().MetricTypes().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoMetricTypes) WithValue(value []string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoMetricTypes) WithArrayOfValues(values [][]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorTsInfoMetricTypes) WithItemValue(value string) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorTsInfoResourceTypes struct{}

func (AlertPathSelectorTsInfoResourceTypes) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().ResourceTypes().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoResourceTypes) WithValue(value []string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoResourceTypes) WithArrayOfValues(values [][]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorTsInfoResourceTypes) WithItemValue(value string) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorTsInfoCommonMetricLabels struct{}

func (AlertPathSelectorTsInfoCommonMetricLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().CommonMetricLabels().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoCommonMetricLabels) WithValue(value map[string]string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoCommonMetricLabels) WithArrayOfValues(values []map[string]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorTsInfoCommonMetricLabels) WithKey(key string) AlertMapPathSelectorTsInfoCommonMetricLabels {
	return AlertMapPathSelectorTsInfoCommonMetricLabels{key: key}
}

type AlertMapPathSelectorTsInfoCommonMetricLabels struct {
	key string
}

func (s AlertMapPathSelectorTsInfoCommonMetricLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().CommonMetricLabels().WithKey(s.key).FieldPath(),
	}
}

func (s AlertMapPathSelectorTsInfoCommonMetricLabels) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertMapPathSelectorTsInfoCommonMetricLabels) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoCommonResourceLabels struct{}

func (AlertPathSelectorTsInfoCommonResourceLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().CommonResourceLabels().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoCommonResourceLabels) WithValue(value map[string]string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoCommonResourceLabels) WithArrayOfValues(values []map[string]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorTsInfoCommonResourceLabels) WithKey(key string) AlertMapPathSelectorTsInfoCommonResourceLabels {
	return AlertMapPathSelectorTsInfoCommonResourceLabels{key: key}
}

type AlertMapPathSelectorTsInfoCommonResourceLabels struct {
	key string
}

func (s AlertMapPathSelectorTsInfoCommonResourceLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().CommonResourceLabels().WithKey(s.key).FieldPath(),
	}
}

func (s AlertMapPathSelectorTsInfoCommonResourceLabels) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertMapPathSelectorTsInfoCommonResourceLabels) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeries struct{}

func (AlertPathSelectorTsInfoTimeSeries) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeries) WithValue(value []*Alert_TsInfo_TimeSeries) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeries) WithArrayOfValues(values [][]*Alert_TsInfo_TimeSeries) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorTsInfoTimeSeries) WithItemValue(value *Alert_TsInfo_TimeSeries) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

func (AlertPathSelectorTsInfoTimeSeries) QueryName() AlertPathSelectorTsInfoTimeSeriesQueryName {
	return AlertPathSelectorTsInfoTimeSeriesQueryName{}
}

func (AlertPathSelectorTsInfoTimeSeries) Values() AlertPathSelectorTsInfoTimeSeriesValues {
	return AlertPathSelectorTsInfoTimeSeriesValues{}
}

func (AlertPathSelectorTsInfoTimeSeries) Anomalies() AlertPathSelectorTsInfoTimeSeriesAnomalies {
	return AlertPathSelectorTsInfoTimeSeriesAnomalies{}
}

func (AlertPathSelectorTsInfoTimeSeries) UpperThreshold() AlertPathSelectorTsInfoTimeSeriesUpperThreshold {
	return AlertPathSelectorTsInfoTimeSeriesUpperThreshold{}
}

func (AlertPathSelectorTsInfoTimeSeries) LowerThreshold() AlertPathSelectorTsInfoTimeSeriesLowerThreshold {
	return AlertPathSelectorTsInfoTimeSeriesLowerThreshold{}
}

func (AlertPathSelectorTsInfoTimeSeries) AnomalyThreshold() AlertPathSelectorTsInfoTimeSeriesAnomalyThreshold {
	return AlertPathSelectorTsInfoTimeSeriesAnomalyThreshold{}
}

func (AlertPathSelectorTsInfoTimeSeries) AfterDuration() AlertPathSelectorTsInfoTimeSeriesAfterDuration {
	return AlertPathSelectorTsInfoTimeSeriesAfterDuration{}
}

type AlertPathSelectorTsInfoTimeSeriesQueryName struct{}

func (AlertPathSelectorTsInfoTimeSeriesQueryName) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().QueryName().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesQueryName) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesQueryName) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeriesValues struct{}

func (AlertPathSelectorTsInfoTimeSeriesValues) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().Values().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesValues) WithValue(value []float64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesValues) WithArrayOfValues(values [][]float64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorTsInfoTimeSeriesValues) WithItemValue(value float64) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorTsInfoTimeSeriesAnomalies struct{}

func (AlertPathSelectorTsInfoTimeSeriesAnomalies) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().Anomalies().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesAnomalies) WithValue(value []float64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesAnomalies) WithArrayOfValues(values [][]float64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorTsInfoTimeSeriesAnomalies) WithItemValue(value float64) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorTsInfoTimeSeriesUpperThreshold struct{}

func (AlertPathSelectorTsInfoTimeSeriesUpperThreshold) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().UpperThreshold().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesUpperThreshold) WithValue(value *rcommon.AlertingThreshold) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesUpperThreshold) WithArrayOfValues(values []*rcommon.AlertingThreshold) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorTsInfoTimeSeriesUpperThreshold) Value() AlertPathSelectorTsInfoTimeSeriesUpperThresholdValue {
	return AlertPathSelectorTsInfoTimeSeriesUpperThresholdValue{}
}

func (AlertPathSelectorTsInfoTimeSeriesUpperThreshold) IsInclusive() AlertPathSelectorTsInfoTimeSeriesUpperThresholdIsInclusive {
	return AlertPathSelectorTsInfoTimeSeriesUpperThresholdIsInclusive{}
}

type AlertPathSelectorTsInfoTimeSeriesUpperThresholdValue struct{}

func (AlertPathSelectorTsInfoTimeSeriesUpperThresholdValue) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().UpperThreshold().Value().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesUpperThresholdValue) WithValue(value float64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesUpperThresholdValue) WithArrayOfValues(values []float64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeriesUpperThresholdIsInclusive struct{}

func (AlertPathSelectorTsInfoTimeSeriesUpperThresholdIsInclusive) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().UpperThreshold().IsInclusive().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesUpperThresholdIsInclusive) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesUpperThresholdIsInclusive) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeriesLowerThreshold struct{}

func (AlertPathSelectorTsInfoTimeSeriesLowerThreshold) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().LowerThreshold().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesLowerThreshold) WithValue(value *rcommon.AlertingThreshold) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesLowerThreshold) WithArrayOfValues(values []*rcommon.AlertingThreshold) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorTsInfoTimeSeriesLowerThreshold) Value() AlertPathSelectorTsInfoTimeSeriesLowerThresholdValue {
	return AlertPathSelectorTsInfoTimeSeriesLowerThresholdValue{}
}

func (AlertPathSelectorTsInfoTimeSeriesLowerThreshold) IsInclusive() AlertPathSelectorTsInfoTimeSeriesLowerThresholdIsInclusive {
	return AlertPathSelectorTsInfoTimeSeriesLowerThresholdIsInclusive{}
}

type AlertPathSelectorTsInfoTimeSeriesLowerThresholdValue struct{}

func (AlertPathSelectorTsInfoTimeSeriesLowerThresholdValue) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().LowerThreshold().Value().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesLowerThresholdValue) WithValue(value float64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesLowerThresholdValue) WithArrayOfValues(values []float64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeriesLowerThresholdIsInclusive struct{}

func (AlertPathSelectorTsInfoTimeSeriesLowerThresholdIsInclusive) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().LowerThreshold().IsInclusive().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesLowerThresholdIsInclusive) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesLowerThresholdIsInclusive) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeriesAnomalyThreshold struct{}

func (AlertPathSelectorTsInfoTimeSeriesAnomalyThreshold) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().AnomalyThreshold().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesAnomalyThreshold) WithValue(value float64) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesAnomalyThreshold) WithArrayOfValues(values []float64) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorTsInfoTimeSeriesAfterDuration struct{}

func (AlertPathSelectorTsInfoTimeSeriesAfterDuration) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorTsInfo,
		subPath:  NewAlertTsInfoFieldPathBuilder().TimeSeries().AfterDuration().FieldPath(),
	}
}

func (s AlertPathSelectorTsInfoTimeSeriesAfterDuration) WithValue(value *durationpb.Duration) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorTsInfoTimeSeriesAfterDuration) WithArrayOfValues(values []*durationpb.Duration) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorLogInfo struct{}

func (AlertPathSelectorLogInfo) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorLogInfo}
}

func (s AlertPathSelectorLogInfo) WithValue(value *Alert_LogInfo) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorLogInfo) WithArrayOfValues(values []*Alert_LogInfo) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

func (AlertPathSelectorLogInfo) WithSubPath(subPath AlertLogInfo_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorLogInfo, subPath: subPath}
}

func (s AlertPathSelectorLogInfo) WithSubValue(subPathValue AlertLogInfo_FieldPathValue) *Alert_FieldSubPathValue {
	return &Alert_FieldSubPathValue{Alert_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertPathSelectorLogInfo) WithSubArrayOfValues(subPathArrayOfValues AlertLogInfo_FieldPathArrayOfValues) *Alert_FieldSubPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{Alert_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertPathSelectorLogInfo) WithSubArrayItemValue(subPathArrayItemValue AlertLogInfo_FieldPathArrayItemValue) *Alert_FieldSubPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{Alert_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertPathSelectorLogInfo) CommonKey() AlertPathSelectorLogInfoCommonKey {
	return AlertPathSelectorLogInfoCommonKey{}
}

func (AlertPathSelectorLogInfo) LogTypes() AlertPathSelectorLogInfoLogTypes {
	return AlertPathSelectorLogInfoLogTypes{}
}

func (AlertPathSelectorLogInfo) CommonLogLabels() AlertPathSelectorLogInfoCommonLogLabels {
	return AlertPathSelectorLogInfoCommonLogLabels{}
}

func (AlertPathSelectorLogInfo) ViolatingLog() AlertPathSelectorLogInfoViolatingLog {
	return AlertPathSelectorLogInfoViolatingLog{}
}

type AlertPathSelectorLogInfoCommonKey struct{}

func (AlertPathSelectorLogInfoCommonKey) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorLogInfo,
		subPath:  NewAlertLogInfoFieldPathBuilder().CommonKey().FieldPath(),
	}
}

func (s AlertPathSelectorLogInfoCommonKey) WithValue(value []byte) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorLogInfoCommonKey) WithArrayOfValues(values [][]byte) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorLogInfoLogTypes struct{}

func (AlertPathSelectorLogInfoLogTypes) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorLogInfo,
		subPath:  NewAlertLogInfoFieldPathBuilder().LogTypes().FieldPath(),
	}
}

func (s AlertPathSelectorLogInfoLogTypes) WithValue(value []string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorLogInfoLogTypes) WithArrayOfValues(values [][]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorLogInfoLogTypes) WithItemValue(value string) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorLogInfoCommonLogLabels struct{}

func (AlertPathSelectorLogInfoCommonLogLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorLogInfo,
		subPath:  NewAlertLogInfoFieldPathBuilder().CommonLogLabels().FieldPath(),
	}
}

func (s AlertPathSelectorLogInfoCommonLogLabels) WithValue(value map[string]string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorLogInfoCommonLogLabels) WithArrayOfValues(values []map[string]string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorLogInfoCommonLogLabels) WithKey(key string) AlertMapPathSelectorLogInfoCommonLogLabels {
	return AlertMapPathSelectorLogInfoCommonLogLabels{key: key}
}

type AlertMapPathSelectorLogInfoCommonLogLabels struct {
	key string
}

func (s AlertMapPathSelectorLogInfoCommonLogLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorLogInfo,
		subPath:  NewAlertLogInfoFieldPathBuilder().CommonLogLabels().WithKey(s.key).FieldPath(),
	}
}

func (s AlertMapPathSelectorLogInfoCommonLogLabels) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertMapPathSelectorLogInfoCommonLogLabels) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorLogInfoViolatingLog struct{}

func (AlertPathSelectorLogInfoViolatingLog) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorLogInfo,
		subPath:  NewAlertLogInfoFieldPathBuilder().ViolatingLog().FieldPath(),
	}
}

func (s AlertPathSelectorLogInfoViolatingLog) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorLogInfoViolatingLog) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorState struct{}

func (AlertPathSelectorState) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorState}
}

func (s AlertPathSelectorState) WithValue(value *Alert_State) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorState) WithArrayOfValues(values []*Alert_State) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

func (AlertPathSelectorState) WithSubPath(subPath AlertState_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorState, subPath: subPath}
}

func (s AlertPathSelectorState) WithSubValue(subPathValue AlertState_FieldPathValue) *Alert_FieldSubPathValue {
	return &Alert_FieldSubPathValue{Alert_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertPathSelectorState) WithSubArrayOfValues(subPathArrayOfValues AlertState_FieldPathArrayOfValues) *Alert_FieldSubPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{Alert_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertPathSelectorState) WithSubArrayItemValue(subPathArrayItemValue AlertState_FieldPathArrayItemValue) *Alert_FieldSubPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{Alert_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertPathSelectorState) IsFiring() AlertPathSelectorStateIsFiring {
	return AlertPathSelectorStateIsFiring{}
}

func (AlertPathSelectorState) StartTime() AlertPathSelectorStateStartTime {
	return AlertPathSelectorStateStartTime{}
}

func (AlertPathSelectorState) EndTime() AlertPathSelectorStateEndTime {
	return AlertPathSelectorStateEndTime{}
}

func (AlertPathSelectorState) NotificationStatuses() AlertPathSelectorStateNotificationStatuses {
	return AlertPathSelectorStateNotificationStatuses{}
}

func (AlertPathSelectorState) EscalationLevel() AlertPathSelectorStateEscalationLevel {
	return AlertPathSelectorStateEscalationLevel{}
}

func (AlertPathSelectorState) AiAgentHandlingState() AlertPathSelectorStateAiAgentHandlingState {
	return AlertPathSelectorStateAiAgentHandlingState{}
}

func (AlertPathSelectorState) AiAgentLastStateChangeTime() AlertPathSelectorStateAiAgentLastStateChangeTime {
	return AlertPathSelectorStateAiAgentLastStateChangeTime{}
}

func (AlertPathSelectorState) AiAgentDiagnosisNotes() AlertPathSelectorStateAiAgentDiagnosisNotes {
	return AlertPathSelectorStateAiAgentDiagnosisNotes{}
}

func (AlertPathSelectorState) AiRemediationArg() AlertPathSelectorStateAiRemediationArg {
	return AlertPathSelectorStateAiRemediationArg{}
}

func (AlertPathSelectorState) AiRemediation() AlertPathSelectorStateAiRemediation {
	return AlertPathSelectorStateAiRemediation{}
}

func (AlertPathSelectorState) OperatorHandlingState() AlertPathSelectorStateOperatorHandlingState {
	return AlertPathSelectorStateOperatorHandlingState{}
}

func (AlertPathSelectorState) OperatorLastStateChangeTime() AlertPathSelectorStateOperatorLastStateChangeTime {
	return AlertPathSelectorStateOperatorLastStateChangeTime{}
}

func (AlertPathSelectorState) OperatorNotes() AlertPathSelectorStateOperatorNotes {
	return AlertPathSelectorStateOperatorNotes{}
}

func (AlertPathSelectorState) LifecycleCompleted() AlertPathSelectorStateLifecycleCompleted {
	return AlertPathSelectorStateLifecycleCompleted{}
}

type AlertPathSelectorStateIsFiring struct{}

func (AlertPathSelectorStateIsFiring) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().IsFiring().FieldPath(),
	}
}

func (s AlertPathSelectorStateIsFiring) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateIsFiring) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateStartTime struct{}

func (AlertPathSelectorStateStartTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().StartTime().FieldPath(),
	}
}

func (s AlertPathSelectorStateStartTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateStartTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateEndTime struct{}

func (AlertPathSelectorStateEndTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().EndTime().FieldPath(),
	}
}

func (s AlertPathSelectorStateEndTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateEndTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateNotificationStatuses struct{}

func (AlertPathSelectorStateNotificationStatuses) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().NotificationStatuses().FieldPath(),
	}
}

func (s AlertPathSelectorStateNotificationStatuses) WithValue(value []*Alert_State_Notification) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateNotificationStatuses) WithArrayOfValues(values [][]*Alert_State_Notification) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorStateNotificationStatuses) WithItemValue(value *Alert_State_Notification) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

func (AlertPathSelectorStateNotificationStatuses) Kind() AlertPathSelectorStateNotificationStatusesKind {
	return AlertPathSelectorStateNotificationStatusesKind{}
}

func (AlertPathSelectorStateNotificationStatuses) PendingChannels() AlertPathSelectorStateNotificationStatusesPendingChannels {
	return AlertPathSelectorStateNotificationStatusesPendingChannels{}
}

type AlertPathSelectorStateNotificationStatusesKind struct{}

func (AlertPathSelectorStateNotificationStatusesKind) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().NotificationStatuses().Kind().FieldPath(),
	}
}

func (s AlertPathSelectorStateNotificationStatusesKind) WithValue(value rcommon.NotificationChannelSpec_EventKind) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateNotificationStatusesKind) WithArrayOfValues(values []rcommon.NotificationChannelSpec_EventKind) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateNotificationStatusesPendingChannels struct{}

func (AlertPathSelectorStateNotificationStatusesPendingChannels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().NotificationStatuses().PendingChannels().FieldPath(),
	}
}

func (s AlertPathSelectorStateNotificationStatusesPendingChannels) WithValue(value []*notification_channel.Reference) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateNotificationStatusesPendingChannels) WithArrayOfValues(values [][]*notification_channel.Reference) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (s AlertPathSelectorStateNotificationStatusesPendingChannels) WithItemValue(value *notification_channel.Reference) *Alert_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Alert_FieldSubPathArrayItemValue)
}

type AlertPathSelectorStateEscalationLevel struct{}

func (AlertPathSelectorStateEscalationLevel) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().EscalationLevel().FieldPath(),
	}
}

func (s AlertPathSelectorStateEscalationLevel) WithValue(value Alert_State_EscalationLevel) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateEscalationLevel) WithArrayOfValues(values []Alert_State_EscalationLevel) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateAiAgentHandlingState struct{}

func (AlertPathSelectorStateAiAgentHandlingState) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiAgentHandlingState().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiAgentHandlingState) WithValue(value Alert_State_AiHandlingState) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiAgentHandlingState) WithArrayOfValues(values []Alert_State_AiHandlingState) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateAiAgentLastStateChangeTime struct{}

func (AlertPathSelectorStateAiAgentLastStateChangeTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiAgentLastStateChangeTime().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiAgentLastStateChangeTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiAgentLastStateChangeTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateAiAgentDiagnosisNotes struct{}

func (AlertPathSelectorStateAiAgentDiagnosisNotes) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiAgentDiagnosisNotes().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiAgentDiagnosisNotes) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiAgentDiagnosisNotes) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateAiRemediationArg struct{}

func (AlertPathSelectorStateAiRemediationArg) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiRemediationArg().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiRemediationArg) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiRemediationArg) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateAiRemediation struct{}

func (AlertPathSelectorStateAiRemediation) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiRemediation().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiRemediation) WithValue(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiRemediation) WithArrayOfValues(values []*rcommon.PolicySpec_AIAgentHandling_Remediation) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorStateAiRemediation) FixInSsh() AlertPathSelectorStateAiRemediationFixInSsh {
	return AlertPathSelectorStateAiRemediationFixInSsh{}
}

func (AlertPathSelectorStateAiRemediation) Reboot() AlertPathSelectorStateAiRemediationReboot {
	return AlertPathSelectorStateAiRemediationReboot{}
}

type AlertPathSelectorStateAiRemediationFixInSsh struct{}

func (AlertPathSelectorStateAiRemediationFixInSsh) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiRemediation().FixInSsh().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiRemediationFixInSsh) WithValue(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiRemediationFixInSsh) WithArrayOfValues(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateAiRemediationReboot struct{}

func (AlertPathSelectorStateAiRemediationReboot) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().AiRemediation().Reboot().FieldPath(),
	}
}

func (s AlertPathSelectorStateAiRemediationReboot) WithValue(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateAiRemediationReboot) WithArrayOfValues(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateOperatorHandlingState struct{}

func (AlertPathSelectorStateOperatorHandlingState) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().OperatorHandlingState().FieldPath(),
	}
}

func (s AlertPathSelectorStateOperatorHandlingState) WithValue(value Alert_State_OperatorHandlingState) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateOperatorHandlingState) WithArrayOfValues(values []Alert_State_OperatorHandlingState) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateOperatorLastStateChangeTime struct{}

func (AlertPathSelectorStateOperatorLastStateChangeTime) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().OperatorLastStateChangeTime().FieldPath(),
	}
}

func (s AlertPathSelectorStateOperatorLastStateChangeTime) WithValue(value *timestamppb.Timestamp) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateOperatorLastStateChangeTime) WithArrayOfValues(values []*timestamppb.Timestamp) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateOperatorNotes struct{}

func (AlertPathSelectorStateOperatorNotes) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().OperatorNotes().FieldPath(),
	}
}

func (s AlertPathSelectorStateOperatorNotes) WithValue(value string) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateOperatorNotes) WithArrayOfValues(values []string) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorStateLifecycleCompleted struct{}

func (AlertPathSelectorStateLifecycleCompleted) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorState,
		subPath:  NewAlertStateFieldPathBuilder().LifecycleCompleted().FieldPath(),
	}
}

func (s AlertPathSelectorStateLifecycleCompleted) WithValue(value bool) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateLifecycleCompleted) WithArrayOfValues(values []bool) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertPathSelectorInternal struct{}

func (AlertPathSelectorInternal) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorInternal}
}

func (s AlertPathSelectorInternal) WithValue(value *Alert_Internal) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

func (s AlertPathSelectorInternal) WithArrayOfValues(values []*Alert_Internal) *Alert_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldTerminalPathArrayOfValues)
}

func (AlertPathSelectorInternal) WithSubPath(subPath AlertInternal_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorInternal, subPath: subPath}
}

func (s AlertPathSelectorInternal) WithSubValue(subPathValue AlertInternal_FieldPathValue) *Alert_FieldSubPathValue {
	return &Alert_FieldSubPathValue{Alert_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertPathSelectorInternal) WithSubArrayOfValues(subPathArrayOfValues AlertInternal_FieldPathArrayOfValues) *Alert_FieldSubPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{Alert_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertPathSelectorInternal) WithSubArrayItemValue(subPathArrayItemValue AlertInternal_FieldPathArrayItemValue) *Alert_FieldSubPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{Alert_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertPathSelectorInternal) AlertingLocation() AlertPathSelectorInternalAlertingLocation {
	return AlertPathSelectorInternalAlertingLocation{}
}

type AlertPathSelectorInternalAlertingLocation struct{}

func (AlertPathSelectorInternalAlertingLocation) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInternal,
		subPath:  NewAlertInternalFieldPathBuilder().AlertingLocation().FieldPath(),
	}
}

func (s AlertPathSelectorInternalAlertingLocation) WithValue(value rcommon.PolicySpec_ProcessingLocation) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorInternalAlertingLocation) WithArrayOfValues(values []rcommon.PolicySpec_ProcessingLocation) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

type AlertTsInfoFieldPathBuilder struct{}

func NewAlertTsInfoFieldPathBuilder() AlertTsInfoFieldPathBuilder {
	return AlertTsInfoFieldPathBuilder{}
}
func (AlertTsInfoFieldPathBuilder) Type() Alert_TsInfoPathSelectorType {
	return Alert_TsInfoPathSelectorType{}
}
func (AlertTsInfoFieldPathBuilder) AnomalyWindowSize() Alert_TsInfoPathSelectorAnomalyWindowSize {
	return Alert_TsInfoPathSelectorAnomalyWindowSize{}
}
func (AlertTsInfoFieldPathBuilder) CommonKey() Alert_TsInfoPathSelectorCommonKey {
	return Alert_TsInfoPathSelectorCommonKey{}
}
func (AlertTsInfoFieldPathBuilder) MetricTypes() Alert_TsInfoPathSelectorMetricTypes {
	return Alert_TsInfoPathSelectorMetricTypes{}
}
func (AlertTsInfoFieldPathBuilder) ResourceTypes() Alert_TsInfoPathSelectorResourceTypes {
	return Alert_TsInfoPathSelectorResourceTypes{}
}
func (AlertTsInfoFieldPathBuilder) CommonMetricLabels() Alert_TsInfoPathSelectorCommonMetricLabels {
	return Alert_TsInfoPathSelectorCommonMetricLabels{}
}
func (AlertTsInfoFieldPathBuilder) CommonResourceLabels() Alert_TsInfoPathSelectorCommonResourceLabels {
	return Alert_TsInfoPathSelectorCommonResourceLabels{}
}
func (AlertTsInfoFieldPathBuilder) TimeSeries() Alert_TsInfoPathSelectorTimeSeries {
	return Alert_TsInfoPathSelectorTimeSeries{}
}

type Alert_TsInfoPathSelectorType struct{}

func (Alert_TsInfoPathSelectorType) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorType}
}

func (s Alert_TsInfoPathSelectorType) WithValue(value Alert_TsInfo_Type) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorType) WithArrayOfValues(values []Alert_TsInfo_Type) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

type Alert_TsInfoPathSelectorAnomalyWindowSize struct{}

func (Alert_TsInfoPathSelectorAnomalyWindowSize) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorAnomalyWindowSize}
}

func (s Alert_TsInfoPathSelectorAnomalyWindowSize) WithValue(value *durationpb.Duration) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorAnomalyWindowSize) WithArrayOfValues(values []*durationpb.Duration) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

type Alert_TsInfoPathSelectorCommonKey struct{}

func (Alert_TsInfoPathSelectorCommonKey) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonKey}
}

func (s Alert_TsInfoPathSelectorCommonKey) WithValue(value []byte) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorCommonKey) WithArrayOfValues(values [][]byte) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

type Alert_TsInfoPathSelectorMetricTypes struct{}

func (Alert_TsInfoPathSelectorMetricTypes) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorMetricTypes}
}

func (s Alert_TsInfoPathSelectorMetricTypes) WithValue(value []string) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorMetricTypes) WithArrayOfValues(values [][]string) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

func (s Alert_TsInfoPathSelectorMetricTypes) WithItemValue(value string) *AlertTsInfo_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfo_FieldTerminalPathArrayItemValue)
}

type Alert_TsInfoPathSelectorResourceTypes struct{}

func (Alert_TsInfoPathSelectorResourceTypes) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorResourceTypes}
}

func (s Alert_TsInfoPathSelectorResourceTypes) WithValue(value []string) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorResourceTypes) WithArrayOfValues(values [][]string) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

func (s Alert_TsInfoPathSelectorResourceTypes) WithItemValue(value string) *AlertTsInfo_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfo_FieldTerminalPathArrayItemValue)
}

type Alert_TsInfoPathSelectorCommonMetricLabels struct{}

func (Alert_TsInfoPathSelectorCommonMetricLabels) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonMetricLabels}
}

func (s Alert_TsInfoPathSelectorCommonMetricLabels) WithValue(value map[string]string) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorCommonMetricLabels) WithArrayOfValues(values []map[string]string) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

func (Alert_TsInfoPathSelectorCommonMetricLabels) WithKey(key string) Alert_TsInfoMapPathSelectorCommonMetricLabels {
	return Alert_TsInfoMapPathSelectorCommonMetricLabels{key: key}
}

type Alert_TsInfoMapPathSelectorCommonMetricLabels struct {
	key string
}

func (s Alert_TsInfoMapPathSelectorCommonMetricLabels) FieldPath() *AlertTsInfo_FieldPathMap {
	return &AlertTsInfo_FieldPathMap{selector: AlertTsInfo_FieldPathSelectorCommonMetricLabels, key: s.key}
}

func (s Alert_TsInfoMapPathSelectorCommonMetricLabels) WithValue(value string) *AlertTsInfo_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldPathMapValue)
}

func (s Alert_TsInfoMapPathSelectorCommonMetricLabels) WithArrayOfValues(values []string) *AlertTsInfo_FieldPathMapArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldPathMapArrayOfValues)
}

type Alert_TsInfoPathSelectorCommonResourceLabels struct{}

func (Alert_TsInfoPathSelectorCommonResourceLabels) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonResourceLabels}
}

func (s Alert_TsInfoPathSelectorCommonResourceLabels) WithValue(value map[string]string) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorCommonResourceLabels) WithArrayOfValues(values []map[string]string) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

func (Alert_TsInfoPathSelectorCommonResourceLabels) WithKey(key string) Alert_TsInfoMapPathSelectorCommonResourceLabels {
	return Alert_TsInfoMapPathSelectorCommonResourceLabels{key: key}
}

type Alert_TsInfoMapPathSelectorCommonResourceLabels struct {
	key string
}

func (s Alert_TsInfoMapPathSelectorCommonResourceLabels) FieldPath() *AlertTsInfo_FieldPathMap {
	return &AlertTsInfo_FieldPathMap{selector: AlertTsInfo_FieldPathSelectorCommonResourceLabels, key: s.key}
}

func (s Alert_TsInfoMapPathSelectorCommonResourceLabels) WithValue(value string) *AlertTsInfo_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldPathMapValue)
}

func (s Alert_TsInfoMapPathSelectorCommonResourceLabels) WithArrayOfValues(values []string) *AlertTsInfo_FieldPathMapArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldPathMapArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeries struct{}

func (Alert_TsInfoPathSelectorTimeSeries) FieldPath() *AlertTsInfo_FieldTerminalPath {
	return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorTimeSeries}
}

func (s Alert_TsInfoPathSelectorTimeSeries) WithValue(value []*Alert_TsInfo_TimeSeries) *AlertTsInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldTerminalPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeries) WithArrayOfValues(values [][]*Alert_TsInfo_TimeSeries) *AlertTsInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldTerminalPathArrayOfValues)
}

func (s Alert_TsInfoPathSelectorTimeSeries) WithItemValue(value *Alert_TsInfo_TimeSeries) *AlertTsInfo_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfo_FieldTerminalPathArrayItemValue)
}
func (Alert_TsInfoPathSelectorTimeSeries) WithSubPath(subPath AlertTsInfoTimeSeries_FieldPath) *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{selector: AlertTsInfo_FieldPathSelectorTimeSeries, subPath: subPath}
}

func (s Alert_TsInfoPathSelectorTimeSeries) WithSubValue(subPathValue AlertTsInfoTimeSeries_FieldPathValue) *AlertTsInfo_FieldSubPathValue {
	return &AlertTsInfo_FieldSubPathValue{AlertTsInfo_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_TsInfoPathSelectorTimeSeries) WithSubArrayOfValues(subPathArrayOfValues AlertTsInfoTimeSeries_FieldPathArrayOfValues) *AlertTsInfo_FieldSubPathArrayOfValues {
	return &AlertTsInfo_FieldSubPathArrayOfValues{AlertTsInfo_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_TsInfoPathSelectorTimeSeries) WithSubArrayItemValue(subPathArrayItemValue AlertTsInfoTimeSeries_FieldPathArrayItemValue) *AlertTsInfo_FieldSubPathArrayItemValue {
	return &AlertTsInfo_FieldSubPathArrayItemValue{AlertTsInfo_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_TsInfoPathSelectorTimeSeries) QueryName() Alert_TsInfoPathSelectorTimeSeriesQueryName {
	return Alert_TsInfoPathSelectorTimeSeriesQueryName{}
}

func (Alert_TsInfoPathSelectorTimeSeries) Values() Alert_TsInfoPathSelectorTimeSeriesValues {
	return Alert_TsInfoPathSelectorTimeSeriesValues{}
}

func (Alert_TsInfoPathSelectorTimeSeries) Anomalies() Alert_TsInfoPathSelectorTimeSeriesAnomalies {
	return Alert_TsInfoPathSelectorTimeSeriesAnomalies{}
}

func (Alert_TsInfoPathSelectorTimeSeries) UpperThreshold() Alert_TsInfoPathSelectorTimeSeriesUpperThreshold {
	return Alert_TsInfoPathSelectorTimeSeriesUpperThreshold{}
}

func (Alert_TsInfoPathSelectorTimeSeries) LowerThreshold() Alert_TsInfoPathSelectorTimeSeriesLowerThreshold {
	return Alert_TsInfoPathSelectorTimeSeriesLowerThreshold{}
}

func (Alert_TsInfoPathSelectorTimeSeries) AnomalyThreshold() Alert_TsInfoPathSelectorTimeSeriesAnomalyThreshold {
	return Alert_TsInfoPathSelectorTimeSeriesAnomalyThreshold{}
}

func (Alert_TsInfoPathSelectorTimeSeries) AfterDuration() Alert_TsInfoPathSelectorTimeSeriesAfterDuration {
	return Alert_TsInfoPathSelectorTimeSeriesAfterDuration{}
}

type Alert_TsInfoPathSelectorTimeSeriesQueryName struct{}

func (Alert_TsInfoPathSelectorTimeSeriesQueryName) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().QueryName().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesQueryName) WithValue(value string) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesQueryName) WithArrayOfValues(values []string) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeriesValues struct{}

func (Alert_TsInfoPathSelectorTimeSeriesValues) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().Values().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesValues) WithValue(value []float64) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesValues) WithArrayOfValues(values [][]float64) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

func (s Alert_TsInfoPathSelectorTimeSeriesValues) WithItemValue(value float64) *AlertTsInfo_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfo_FieldSubPathArrayItemValue)
}

type Alert_TsInfoPathSelectorTimeSeriesAnomalies struct{}

func (Alert_TsInfoPathSelectorTimeSeriesAnomalies) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().Anomalies().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesAnomalies) WithValue(value []float64) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesAnomalies) WithArrayOfValues(values [][]float64) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

func (s Alert_TsInfoPathSelectorTimeSeriesAnomalies) WithItemValue(value float64) *AlertTsInfo_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfo_FieldSubPathArrayItemValue)
}

type Alert_TsInfoPathSelectorTimeSeriesUpperThreshold struct{}

func (Alert_TsInfoPathSelectorTimeSeriesUpperThreshold) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().UpperThreshold().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesUpperThreshold) WithValue(value *rcommon.AlertingThreshold) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesUpperThreshold) WithArrayOfValues(values []*rcommon.AlertingThreshold) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

func (Alert_TsInfoPathSelectorTimeSeriesUpperThreshold) Value() Alert_TsInfoPathSelectorTimeSeriesUpperThresholdValue {
	return Alert_TsInfoPathSelectorTimeSeriesUpperThresholdValue{}
}

func (Alert_TsInfoPathSelectorTimeSeriesUpperThreshold) IsInclusive() Alert_TsInfoPathSelectorTimeSeriesUpperThresholdIsInclusive {
	return Alert_TsInfoPathSelectorTimeSeriesUpperThresholdIsInclusive{}
}

type Alert_TsInfoPathSelectorTimeSeriesUpperThresholdValue struct{}

func (Alert_TsInfoPathSelectorTimeSeriesUpperThresholdValue) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().UpperThreshold().Value().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesUpperThresholdValue) WithValue(value float64) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesUpperThresholdValue) WithArrayOfValues(values []float64) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeriesUpperThresholdIsInclusive struct{}

func (Alert_TsInfoPathSelectorTimeSeriesUpperThresholdIsInclusive) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().UpperThreshold().IsInclusive().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesUpperThresholdIsInclusive) WithValue(value bool) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesUpperThresholdIsInclusive) WithArrayOfValues(values []bool) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeriesLowerThreshold struct{}

func (Alert_TsInfoPathSelectorTimeSeriesLowerThreshold) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().LowerThreshold().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesLowerThreshold) WithValue(value *rcommon.AlertingThreshold) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesLowerThreshold) WithArrayOfValues(values []*rcommon.AlertingThreshold) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

func (Alert_TsInfoPathSelectorTimeSeriesLowerThreshold) Value() Alert_TsInfoPathSelectorTimeSeriesLowerThresholdValue {
	return Alert_TsInfoPathSelectorTimeSeriesLowerThresholdValue{}
}

func (Alert_TsInfoPathSelectorTimeSeriesLowerThreshold) IsInclusive() Alert_TsInfoPathSelectorTimeSeriesLowerThresholdIsInclusive {
	return Alert_TsInfoPathSelectorTimeSeriesLowerThresholdIsInclusive{}
}

type Alert_TsInfoPathSelectorTimeSeriesLowerThresholdValue struct{}

func (Alert_TsInfoPathSelectorTimeSeriesLowerThresholdValue) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().LowerThreshold().Value().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesLowerThresholdValue) WithValue(value float64) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesLowerThresholdValue) WithArrayOfValues(values []float64) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeriesLowerThresholdIsInclusive struct{}

func (Alert_TsInfoPathSelectorTimeSeriesLowerThresholdIsInclusive) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().LowerThreshold().IsInclusive().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesLowerThresholdIsInclusive) WithValue(value bool) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesLowerThresholdIsInclusive) WithArrayOfValues(values []bool) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeriesAnomalyThreshold struct{}

func (Alert_TsInfoPathSelectorTimeSeriesAnomalyThreshold) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().AnomalyThreshold().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesAnomalyThreshold) WithValue(value float64) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesAnomalyThreshold) WithArrayOfValues(values []float64) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type Alert_TsInfoPathSelectorTimeSeriesAfterDuration struct{}

func (Alert_TsInfoPathSelectorTimeSeriesAfterDuration) FieldPath() *AlertTsInfo_FieldSubPath {
	return &AlertTsInfo_FieldSubPath{
		selector: AlertTsInfo_FieldPathSelectorTimeSeries,
		subPath:  NewAlertTsInfoTimeSeriesFieldPathBuilder().AfterDuration().FieldPath(),
	}
}

func (s Alert_TsInfoPathSelectorTimeSeriesAfterDuration) WithValue(value *durationpb.Duration) *AlertTsInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfo_FieldSubPathValue)
}

func (s Alert_TsInfoPathSelectorTimeSeriesAfterDuration) WithArrayOfValues(values []*durationpb.Duration) *AlertTsInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfo_FieldSubPathArrayOfValues)
}

type AlertLogInfoFieldPathBuilder struct{}

func NewAlertLogInfoFieldPathBuilder() AlertLogInfoFieldPathBuilder {
	return AlertLogInfoFieldPathBuilder{}
}
func (AlertLogInfoFieldPathBuilder) CommonKey() Alert_LogInfoPathSelectorCommonKey {
	return Alert_LogInfoPathSelectorCommonKey{}
}
func (AlertLogInfoFieldPathBuilder) LogTypes() Alert_LogInfoPathSelectorLogTypes {
	return Alert_LogInfoPathSelectorLogTypes{}
}
func (AlertLogInfoFieldPathBuilder) CommonLogLabels() Alert_LogInfoPathSelectorCommonLogLabels {
	return Alert_LogInfoPathSelectorCommonLogLabels{}
}
func (AlertLogInfoFieldPathBuilder) ViolatingLog() Alert_LogInfoPathSelectorViolatingLog {
	return Alert_LogInfoPathSelectorViolatingLog{}
}

type Alert_LogInfoPathSelectorCommonKey struct{}

func (Alert_LogInfoPathSelectorCommonKey) FieldPath() *AlertLogInfo_FieldTerminalPath {
	return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonKey}
}

func (s Alert_LogInfoPathSelectorCommonKey) WithValue(value []byte) *AlertLogInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertLogInfo_FieldTerminalPathValue)
}

func (s Alert_LogInfoPathSelectorCommonKey) WithArrayOfValues(values [][]byte) *AlertLogInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertLogInfo_FieldTerminalPathArrayOfValues)
}

type Alert_LogInfoPathSelectorLogTypes struct{}

func (Alert_LogInfoPathSelectorLogTypes) FieldPath() *AlertLogInfo_FieldTerminalPath {
	return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorLogTypes}
}

func (s Alert_LogInfoPathSelectorLogTypes) WithValue(value []string) *AlertLogInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertLogInfo_FieldTerminalPathValue)
}

func (s Alert_LogInfoPathSelectorLogTypes) WithArrayOfValues(values [][]string) *AlertLogInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertLogInfo_FieldTerminalPathArrayOfValues)
}

func (s Alert_LogInfoPathSelectorLogTypes) WithItemValue(value string) *AlertLogInfo_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertLogInfo_FieldTerminalPathArrayItemValue)
}

type Alert_LogInfoPathSelectorCommonLogLabels struct{}

func (Alert_LogInfoPathSelectorCommonLogLabels) FieldPath() *AlertLogInfo_FieldTerminalPath {
	return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonLogLabels}
}

func (s Alert_LogInfoPathSelectorCommonLogLabels) WithValue(value map[string]string) *AlertLogInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertLogInfo_FieldTerminalPathValue)
}

func (s Alert_LogInfoPathSelectorCommonLogLabels) WithArrayOfValues(values []map[string]string) *AlertLogInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertLogInfo_FieldTerminalPathArrayOfValues)
}

func (Alert_LogInfoPathSelectorCommonLogLabels) WithKey(key string) Alert_LogInfoMapPathSelectorCommonLogLabels {
	return Alert_LogInfoMapPathSelectorCommonLogLabels{key: key}
}

type Alert_LogInfoMapPathSelectorCommonLogLabels struct {
	key string
}

func (s Alert_LogInfoMapPathSelectorCommonLogLabels) FieldPath() *AlertLogInfo_FieldPathMap {
	return &AlertLogInfo_FieldPathMap{selector: AlertLogInfo_FieldPathSelectorCommonLogLabels, key: s.key}
}

func (s Alert_LogInfoMapPathSelectorCommonLogLabels) WithValue(value string) *AlertLogInfo_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*AlertLogInfo_FieldPathMapValue)
}

func (s Alert_LogInfoMapPathSelectorCommonLogLabels) WithArrayOfValues(values []string) *AlertLogInfo_FieldPathMapArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertLogInfo_FieldPathMapArrayOfValues)
}

type Alert_LogInfoPathSelectorViolatingLog struct{}

func (Alert_LogInfoPathSelectorViolatingLog) FieldPath() *AlertLogInfo_FieldTerminalPath {
	return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorViolatingLog}
}

func (s Alert_LogInfoPathSelectorViolatingLog) WithValue(value string) *AlertLogInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertLogInfo_FieldTerminalPathValue)
}

func (s Alert_LogInfoPathSelectorViolatingLog) WithArrayOfValues(values []string) *AlertLogInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertLogInfo_FieldTerminalPathArrayOfValues)
}

type AlertStateFieldPathBuilder struct{}

func NewAlertStateFieldPathBuilder() AlertStateFieldPathBuilder {
	return AlertStateFieldPathBuilder{}
}
func (AlertStateFieldPathBuilder) IsFiring() Alert_StatePathSelectorIsFiring {
	return Alert_StatePathSelectorIsFiring{}
}
func (AlertStateFieldPathBuilder) StartTime() Alert_StatePathSelectorStartTime {
	return Alert_StatePathSelectorStartTime{}
}
func (AlertStateFieldPathBuilder) EndTime() Alert_StatePathSelectorEndTime {
	return Alert_StatePathSelectorEndTime{}
}
func (AlertStateFieldPathBuilder) NotificationStatuses() Alert_StatePathSelectorNotificationStatuses {
	return Alert_StatePathSelectorNotificationStatuses{}
}
func (AlertStateFieldPathBuilder) EscalationLevel() Alert_StatePathSelectorEscalationLevel {
	return Alert_StatePathSelectorEscalationLevel{}
}
func (AlertStateFieldPathBuilder) AiAgentHandlingState() Alert_StatePathSelectorAiAgentHandlingState {
	return Alert_StatePathSelectorAiAgentHandlingState{}
}
func (AlertStateFieldPathBuilder) AiAgentLastStateChangeTime() Alert_StatePathSelectorAiAgentLastStateChangeTime {
	return Alert_StatePathSelectorAiAgentLastStateChangeTime{}
}
func (AlertStateFieldPathBuilder) AiAgentDiagnosisNotes() Alert_StatePathSelectorAiAgentDiagnosisNotes {
	return Alert_StatePathSelectorAiAgentDiagnosisNotes{}
}
func (AlertStateFieldPathBuilder) AiRemediationArg() Alert_StatePathSelectorAiRemediationArg {
	return Alert_StatePathSelectorAiRemediationArg{}
}
func (AlertStateFieldPathBuilder) AiRemediation() Alert_StatePathSelectorAiRemediation {
	return Alert_StatePathSelectorAiRemediation{}
}
func (AlertStateFieldPathBuilder) OperatorHandlingState() Alert_StatePathSelectorOperatorHandlingState {
	return Alert_StatePathSelectorOperatorHandlingState{}
}
func (AlertStateFieldPathBuilder) OperatorLastStateChangeTime() Alert_StatePathSelectorOperatorLastStateChangeTime {
	return Alert_StatePathSelectorOperatorLastStateChangeTime{}
}
func (AlertStateFieldPathBuilder) OperatorNotes() Alert_StatePathSelectorOperatorNotes {
	return Alert_StatePathSelectorOperatorNotes{}
}
func (AlertStateFieldPathBuilder) LifecycleCompleted() Alert_StatePathSelectorLifecycleCompleted {
	return Alert_StatePathSelectorLifecycleCompleted{}
}

type Alert_StatePathSelectorIsFiring struct{}

func (Alert_StatePathSelectorIsFiring) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsFiring}
}

func (s Alert_StatePathSelectorIsFiring) WithValue(value bool) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorIsFiring) WithArrayOfValues(values []bool) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorStartTime struct{}

func (Alert_StatePathSelectorStartTime) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorStartTime}
}

func (s Alert_StatePathSelectorStartTime) WithValue(value *timestamppb.Timestamp) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorStartTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorEndTime struct{}

func (Alert_StatePathSelectorEndTime) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorEndTime}
}

func (s Alert_StatePathSelectorEndTime) WithValue(value *timestamppb.Timestamp) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorEndTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorNotificationStatuses struct{}

func (Alert_StatePathSelectorNotificationStatuses) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationStatuses}
}

func (s Alert_StatePathSelectorNotificationStatuses) WithValue(value []*Alert_State_Notification) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorNotificationStatuses) WithArrayOfValues(values [][]*Alert_State_Notification) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

func (s Alert_StatePathSelectorNotificationStatuses) WithItemValue(value *Alert_State_Notification) *AlertState_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertState_FieldTerminalPathArrayItemValue)
}
func (Alert_StatePathSelectorNotificationStatuses) WithSubPath(subPath AlertStateNotification_FieldPath) *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorNotificationStatuses, subPath: subPath}
}

func (s Alert_StatePathSelectorNotificationStatuses) WithSubValue(subPathValue AlertStateNotification_FieldPathValue) *AlertState_FieldSubPathValue {
	return &AlertState_FieldSubPathValue{AlertState_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_StatePathSelectorNotificationStatuses) WithSubArrayOfValues(subPathArrayOfValues AlertStateNotification_FieldPathArrayOfValues) *AlertState_FieldSubPathArrayOfValues {
	return &AlertState_FieldSubPathArrayOfValues{AlertState_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_StatePathSelectorNotificationStatuses) WithSubArrayItemValue(subPathArrayItemValue AlertStateNotification_FieldPathArrayItemValue) *AlertState_FieldSubPathArrayItemValue {
	return &AlertState_FieldSubPathArrayItemValue{AlertState_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_StatePathSelectorNotificationStatuses) Kind() Alert_StatePathSelectorNotificationStatusesKind {
	return Alert_StatePathSelectorNotificationStatusesKind{}
}

func (Alert_StatePathSelectorNotificationStatuses) PendingChannels() Alert_StatePathSelectorNotificationStatusesPendingChannels {
	return Alert_StatePathSelectorNotificationStatusesPendingChannels{}
}

type Alert_StatePathSelectorNotificationStatusesKind struct{}

func (Alert_StatePathSelectorNotificationStatusesKind) FieldPath() *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{
		selector: AlertState_FieldPathSelectorNotificationStatuses,
		subPath:  NewAlertStateNotificationFieldPathBuilder().Kind().FieldPath(),
	}
}

func (s Alert_StatePathSelectorNotificationStatusesKind) WithValue(value rcommon.NotificationChannelSpec_EventKind) *AlertState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldSubPathValue)
}

func (s Alert_StatePathSelectorNotificationStatusesKind) WithArrayOfValues(values []rcommon.NotificationChannelSpec_EventKind) *AlertState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldSubPathArrayOfValues)
}

type Alert_StatePathSelectorNotificationStatusesPendingChannels struct{}

func (Alert_StatePathSelectorNotificationStatusesPendingChannels) FieldPath() *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{
		selector: AlertState_FieldPathSelectorNotificationStatuses,
		subPath:  NewAlertStateNotificationFieldPathBuilder().PendingChannels().FieldPath(),
	}
}

func (s Alert_StatePathSelectorNotificationStatusesPendingChannels) WithValue(value []*notification_channel.Reference) *AlertState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldSubPathValue)
}

func (s Alert_StatePathSelectorNotificationStatusesPendingChannels) WithArrayOfValues(values [][]*notification_channel.Reference) *AlertState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldSubPathArrayOfValues)
}

func (s Alert_StatePathSelectorNotificationStatusesPendingChannels) WithItemValue(value *notification_channel.Reference) *AlertState_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertState_FieldSubPathArrayItemValue)
}

type Alert_StatePathSelectorEscalationLevel struct{}

func (Alert_StatePathSelectorEscalationLevel) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorEscalationLevel}
}

func (s Alert_StatePathSelectorEscalationLevel) WithValue(value Alert_State_EscalationLevel) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorEscalationLevel) WithArrayOfValues(values []Alert_State_EscalationLevel) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorAiAgentHandlingState struct{}

func (Alert_StatePathSelectorAiAgentHandlingState) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentHandlingState}
}

func (s Alert_StatePathSelectorAiAgentHandlingState) WithValue(value Alert_State_AiHandlingState) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorAiAgentHandlingState) WithArrayOfValues(values []Alert_State_AiHandlingState) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorAiAgentLastStateChangeTime struct{}

func (Alert_StatePathSelectorAiAgentLastStateChangeTime) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentLastStateChangeTime}
}

func (s Alert_StatePathSelectorAiAgentLastStateChangeTime) WithValue(value *timestamppb.Timestamp) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorAiAgentLastStateChangeTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorAiAgentDiagnosisNotes struct{}

func (Alert_StatePathSelectorAiAgentDiagnosisNotes) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentDiagnosisNotes}
}

func (s Alert_StatePathSelectorAiAgentDiagnosisNotes) WithValue(value string) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorAiAgentDiagnosisNotes) WithArrayOfValues(values []string) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorAiRemediationArg struct{}

func (Alert_StatePathSelectorAiRemediationArg) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiRemediationArg}
}

func (s Alert_StatePathSelectorAiRemediationArg) WithValue(value string) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorAiRemediationArg) WithArrayOfValues(values []string) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorAiRemediation struct{}

func (Alert_StatePathSelectorAiRemediation) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiRemediation}
}

func (s Alert_StatePathSelectorAiRemediation) WithValue(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorAiRemediation) WithArrayOfValues(values []*rcommon.PolicySpec_AIAgentHandling_Remediation) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

func (Alert_StatePathSelectorAiRemediation) WithSubPath(subPath rcommon.PolicySpecAIAgentHandlingRemediation_FieldPath) *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorAiRemediation, subPath: subPath}
}

func (s Alert_StatePathSelectorAiRemediation) WithSubValue(subPathValue rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue) *AlertState_FieldSubPathValue {
	return &AlertState_FieldSubPathValue{AlertState_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_StatePathSelectorAiRemediation) WithSubArrayOfValues(subPathArrayOfValues rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues) *AlertState_FieldSubPathArrayOfValues {
	return &AlertState_FieldSubPathArrayOfValues{AlertState_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_StatePathSelectorAiRemediation) WithSubArrayItemValue(subPathArrayItemValue rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue) *AlertState_FieldSubPathArrayItemValue {
	return &AlertState_FieldSubPathArrayItemValue{AlertState_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_StatePathSelectorAiRemediation) FixInSsh() Alert_StatePathSelectorAiRemediationFixInSsh {
	return Alert_StatePathSelectorAiRemediationFixInSsh{}
}

func (Alert_StatePathSelectorAiRemediation) Reboot() Alert_StatePathSelectorAiRemediationReboot {
	return Alert_StatePathSelectorAiRemediationReboot{}
}

type Alert_StatePathSelectorAiRemediationFixInSsh struct{}

func (Alert_StatePathSelectorAiRemediationFixInSsh) FieldPath() *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{
		selector: AlertState_FieldPathSelectorAiRemediation,
		subPath:  rcommon.NewPolicySpecAIAgentHandlingRemediationFieldPathBuilder().FixInSsh().FieldPath(),
	}
}

func (s Alert_StatePathSelectorAiRemediationFixInSsh) WithValue(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *AlertState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldSubPathValue)
}

func (s Alert_StatePathSelectorAiRemediationFixInSsh) WithArrayOfValues(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *AlertState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldSubPathArrayOfValues)
}

type Alert_StatePathSelectorAiRemediationReboot struct{}

func (Alert_StatePathSelectorAiRemediationReboot) FieldPath() *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{
		selector: AlertState_FieldPathSelectorAiRemediation,
		subPath:  rcommon.NewPolicySpecAIAgentHandlingRemediationFieldPathBuilder().Reboot().FieldPath(),
	}
}

func (s Alert_StatePathSelectorAiRemediationReboot) WithValue(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *AlertState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldSubPathValue)
}

func (s Alert_StatePathSelectorAiRemediationReboot) WithArrayOfValues(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *AlertState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldSubPathArrayOfValues)
}

type Alert_StatePathSelectorOperatorHandlingState struct{}

func (Alert_StatePathSelectorOperatorHandlingState) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorHandlingState}
}

func (s Alert_StatePathSelectorOperatorHandlingState) WithValue(value Alert_State_OperatorHandlingState) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorOperatorHandlingState) WithArrayOfValues(values []Alert_State_OperatorHandlingState) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorOperatorLastStateChangeTime struct{}

func (Alert_StatePathSelectorOperatorLastStateChangeTime) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorLastStateChangeTime}
}

func (s Alert_StatePathSelectorOperatorLastStateChangeTime) WithValue(value *timestamppb.Timestamp) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorOperatorLastStateChangeTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorOperatorNotes struct{}

func (Alert_StatePathSelectorOperatorNotes) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorNotes}
}

func (s Alert_StatePathSelectorOperatorNotes) WithValue(value string) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorOperatorNotes) WithArrayOfValues(values []string) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type Alert_StatePathSelectorLifecycleCompleted struct{}

func (Alert_StatePathSelectorLifecycleCompleted) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifecycleCompleted}
}

func (s Alert_StatePathSelectorLifecycleCompleted) WithValue(value bool) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorLifecycleCompleted) WithArrayOfValues(values []bool) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

type AlertInternalFieldPathBuilder struct{}

func NewAlertInternalFieldPathBuilder() AlertInternalFieldPathBuilder {
	return AlertInternalFieldPathBuilder{}
}
func (AlertInternalFieldPathBuilder) AlertingLocation() Alert_InternalPathSelectorAlertingLocation {
	return Alert_InternalPathSelectorAlertingLocation{}
}

type Alert_InternalPathSelectorAlertingLocation struct{}

func (Alert_InternalPathSelectorAlertingLocation) FieldPath() *AlertInternal_FieldTerminalPath {
	return &AlertInternal_FieldTerminalPath{selector: AlertInternal_FieldPathSelectorAlertingLocation}
}

func (s Alert_InternalPathSelectorAlertingLocation) WithValue(value rcommon.PolicySpec_ProcessingLocation) *AlertInternal_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInternal_FieldTerminalPathValue)
}

func (s Alert_InternalPathSelectorAlertingLocation) WithArrayOfValues(values []rcommon.PolicySpec_ProcessingLocation) *AlertInternal_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInternal_FieldTerminalPathArrayOfValues)
}

type AlertTsInfoTimeSeriesFieldPathBuilder struct{}

func NewAlertTsInfoTimeSeriesFieldPathBuilder() AlertTsInfoTimeSeriesFieldPathBuilder {
	return AlertTsInfoTimeSeriesFieldPathBuilder{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) QueryName() Alert_TsInfo_TimeSeriesPathSelectorQueryName {
	return Alert_TsInfo_TimeSeriesPathSelectorQueryName{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) Values() Alert_TsInfo_TimeSeriesPathSelectorValues {
	return Alert_TsInfo_TimeSeriesPathSelectorValues{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) Anomalies() Alert_TsInfo_TimeSeriesPathSelectorAnomalies {
	return Alert_TsInfo_TimeSeriesPathSelectorAnomalies{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) UpperThreshold() Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold {
	return Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) LowerThreshold() Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold {
	return Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) AnomalyThreshold() Alert_TsInfo_TimeSeriesPathSelectorAnomalyThreshold {
	return Alert_TsInfo_TimeSeriesPathSelectorAnomalyThreshold{}
}
func (AlertTsInfoTimeSeriesFieldPathBuilder) AfterDuration() Alert_TsInfo_TimeSeriesPathSelectorAfterDuration {
	return Alert_TsInfo_TimeSeriesPathSelectorAfterDuration{}
}

type Alert_TsInfo_TimeSeriesPathSelectorQueryName struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorQueryName) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorQueryName}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorQueryName) WithValue(value string) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorQueryName) WithArrayOfValues(values []string) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

type Alert_TsInfo_TimeSeriesPathSelectorValues struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorValues) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorValues}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorValues) WithValue(value []float64) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorValues) WithArrayOfValues(values [][]float64) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorValues) WithItemValue(value float64) *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue)
}

type Alert_TsInfo_TimeSeriesPathSelectorAnomalies struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorAnomalies) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalies}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAnomalies) WithValue(value []float64) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAnomalies) WithArrayOfValues(values [][]float64) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAnomalies) WithItemValue(value float64) *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue)
}

type Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) WithValue(value *rcommon.AlertingThreshold) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) WithArrayOfValues(values []*rcommon.AlertingThreshold) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

func (Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) WithSubPath(subPath rcommon.AlertingThreshold_FieldPath) *AlertTsInfoTimeSeries_FieldSubPath {
	return &AlertTsInfoTimeSeries_FieldSubPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold, subPath: subPath}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) WithSubValue(subPathValue rcommon.AlertingThreshold_FieldPathValue) *AlertTsInfoTimeSeries_FieldSubPathValue {
	return &AlertTsInfoTimeSeries_FieldSubPathValue{AlertTsInfoTimeSeries_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) WithSubArrayOfValues(subPathArrayOfValues rcommon.AlertingThreshold_FieldPathArrayOfValues) *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues {
	return &AlertTsInfoTimeSeries_FieldSubPathArrayOfValues{AlertTsInfoTimeSeries_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) WithSubArrayItemValue(subPathArrayItemValue rcommon.AlertingThreshold_FieldPathArrayItemValue) *AlertTsInfoTimeSeries_FieldSubPathArrayItemValue {
	return &AlertTsInfoTimeSeries_FieldSubPathArrayItemValue{AlertTsInfoTimeSeries_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) Value() Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdValue {
	return Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdValue{}
}

func (Alert_TsInfo_TimeSeriesPathSelectorUpperThreshold) IsInclusive() Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdIsInclusive {
	return Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdIsInclusive{}
}

type Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdValue struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdValue) FieldPath() *AlertTsInfoTimeSeries_FieldSubPath {
	return &AlertTsInfoTimeSeries_FieldSubPath{
		selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().Value().FieldPath(),
	}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdValue) WithValue(value float64) *AlertTsInfoTimeSeries_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldSubPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdValue) WithArrayOfValues(values []float64) *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldSubPathArrayOfValues)
}

type Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdIsInclusive struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdIsInclusive) FieldPath() *AlertTsInfoTimeSeries_FieldSubPath {
	return &AlertTsInfoTimeSeries_FieldSubPath{
		selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().IsInclusive().FieldPath(),
	}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdIsInclusive) WithValue(value bool) *AlertTsInfoTimeSeries_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldSubPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorUpperThresholdIsInclusive) WithArrayOfValues(values []bool) *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldSubPathArrayOfValues)
}

type Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) WithValue(value *rcommon.AlertingThreshold) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) WithArrayOfValues(values []*rcommon.AlertingThreshold) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

func (Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) WithSubPath(subPath rcommon.AlertingThreshold_FieldPath) *AlertTsInfoTimeSeries_FieldSubPath {
	return &AlertTsInfoTimeSeries_FieldSubPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold, subPath: subPath}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) WithSubValue(subPathValue rcommon.AlertingThreshold_FieldPathValue) *AlertTsInfoTimeSeries_FieldSubPathValue {
	return &AlertTsInfoTimeSeries_FieldSubPathValue{AlertTsInfoTimeSeries_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) WithSubArrayOfValues(subPathArrayOfValues rcommon.AlertingThreshold_FieldPathArrayOfValues) *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues {
	return &AlertTsInfoTimeSeries_FieldSubPathArrayOfValues{AlertTsInfoTimeSeries_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) WithSubArrayItemValue(subPathArrayItemValue rcommon.AlertingThreshold_FieldPathArrayItemValue) *AlertTsInfoTimeSeries_FieldSubPathArrayItemValue {
	return &AlertTsInfoTimeSeries_FieldSubPathArrayItemValue{AlertTsInfoTimeSeries_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) Value() Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdValue {
	return Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdValue{}
}

func (Alert_TsInfo_TimeSeriesPathSelectorLowerThreshold) IsInclusive() Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdIsInclusive {
	return Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdIsInclusive{}
}

type Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdValue struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdValue) FieldPath() *AlertTsInfoTimeSeries_FieldSubPath {
	return &AlertTsInfoTimeSeries_FieldSubPath{
		selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().Value().FieldPath(),
	}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdValue) WithValue(value float64) *AlertTsInfoTimeSeries_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldSubPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdValue) WithArrayOfValues(values []float64) *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldSubPathArrayOfValues)
}

type Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdIsInclusive struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdIsInclusive) FieldPath() *AlertTsInfoTimeSeries_FieldSubPath {
	return &AlertTsInfoTimeSeries_FieldSubPath{
		selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().IsInclusive().FieldPath(),
	}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdIsInclusive) WithValue(value bool) *AlertTsInfoTimeSeries_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldSubPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorLowerThresholdIsInclusive) WithArrayOfValues(values []bool) *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldSubPathArrayOfValues)
}

type Alert_TsInfo_TimeSeriesPathSelectorAnomalyThreshold struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorAnomalyThreshold) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAnomalyThreshold) WithValue(value float64) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAnomalyThreshold) WithArrayOfValues(values []float64) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

type Alert_TsInfo_TimeSeriesPathSelectorAfterDuration struct{}

func (Alert_TsInfo_TimeSeriesPathSelectorAfterDuration) FieldPath() *AlertTsInfoTimeSeries_FieldTerminalPath {
	return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration}
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAfterDuration) WithValue(value *durationpb.Duration) *AlertTsInfoTimeSeries_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertTsInfoTimeSeries_FieldTerminalPathValue)
}

func (s Alert_TsInfo_TimeSeriesPathSelectorAfterDuration) WithArrayOfValues(values []*durationpb.Duration) *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)
}

type AlertStateNotificationFieldPathBuilder struct{}

func NewAlertStateNotificationFieldPathBuilder() AlertStateNotificationFieldPathBuilder {
	return AlertStateNotificationFieldPathBuilder{}
}
func (AlertStateNotificationFieldPathBuilder) Kind() Alert_State_NotificationPathSelectorKind {
	return Alert_State_NotificationPathSelectorKind{}
}
func (AlertStateNotificationFieldPathBuilder) PendingChannels() Alert_State_NotificationPathSelectorPendingChannels {
	return Alert_State_NotificationPathSelectorPendingChannels{}
}

type Alert_State_NotificationPathSelectorKind struct{}

func (Alert_State_NotificationPathSelectorKind) FieldPath() *AlertStateNotification_FieldTerminalPath {
	return &AlertStateNotification_FieldTerminalPath{selector: AlertStateNotification_FieldPathSelectorKind}
}

func (s Alert_State_NotificationPathSelectorKind) WithValue(value rcommon.NotificationChannelSpec_EventKind) *AlertStateNotification_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertStateNotification_FieldTerminalPathValue)
}

func (s Alert_State_NotificationPathSelectorKind) WithArrayOfValues(values []rcommon.NotificationChannelSpec_EventKind) *AlertStateNotification_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertStateNotification_FieldTerminalPathArrayOfValues)
}

type Alert_State_NotificationPathSelectorPendingChannels struct{}

func (Alert_State_NotificationPathSelectorPendingChannels) FieldPath() *AlertStateNotification_FieldTerminalPath {
	return &AlertStateNotification_FieldTerminalPath{selector: AlertStateNotification_FieldPathSelectorPendingChannels}
}

func (s Alert_State_NotificationPathSelectorPendingChannels) WithValue(value []*notification_channel.Reference) *AlertStateNotification_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertStateNotification_FieldTerminalPathValue)
}

func (s Alert_State_NotificationPathSelectorPendingChannels) WithArrayOfValues(values [][]*notification_channel.Reference) *AlertStateNotification_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertStateNotification_FieldTerminalPathArrayOfValues)
}

func (s Alert_State_NotificationPathSelectorPendingChannels) WithItemValue(value *notification_channel.Reference) *AlertStateNotification_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertStateNotification_FieldTerminalPathArrayItemValue)
}