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

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

package alert

// proto imports
import (
	alerting_condition "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_condition"
	alerting_policy "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_policy"
	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common"
	notification_channel "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/notification_channel"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// make sure we're using proto imports
var (
	_ = &alerting_condition.AlertingCondition{}
	_ = &alerting_policy.AlertingPolicy{}
	_ = &common.LabelDescriptor{}
	_ = &notification_channel.NotificationChannel{}
	_ = &project.Project{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
	_ = &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) Info() AlertPathSelectorInfo {
	return AlertPathSelectorInfo{}
}
func (AlertFieldPathBuilder) State() AlertPathSelectorState {
	return AlertPathSelectorState{}
}

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 AlertPathSelectorInfo struct{}

func (AlertPathSelectorInfo) FieldPath() *Alert_FieldTerminalPath {
	return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorInfo}
}

func (s AlertPathSelectorInfo) WithValue(value *Alert_Info) *Alert_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldTerminalPathValue)
}

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

func (AlertPathSelectorInfo) WithSubPath(subPath AlertInfo_FieldPath) *Alert_FieldSubPath {
	return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorInfo, subPath: subPath}
}

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

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

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

func (AlertPathSelectorInfo) TimeSerie() AlertPathSelectorInfoTimeSerie {
	return AlertPathSelectorInfoTimeSerie{}
}

func (AlertPathSelectorInfo) ObservedValues() AlertPathSelectorInfoObservedValues {
	return AlertPathSelectorInfoObservedValues{}
}

type AlertPathSelectorInfoTimeSerie struct{}

func (AlertPathSelectorInfoTimeSerie) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().FieldPath(),
	}
}

func (s AlertPathSelectorInfoTimeSerie) WithValue(value *Alert_Info_TimeSerie) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

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

func (AlertPathSelectorInfoTimeSerie) Key() AlertPathSelectorInfoTimeSerieKey {
	return AlertPathSelectorInfoTimeSerieKey{}
}

func (AlertPathSelectorInfoTimeSerie) Metric() AlertPathSelectorInfoTimeSerieMetric {
	return AlertPathSelectorInfoTimeSerieMetric{}
}

func (AlertPathSelectorInfoTimeSerie) MonitoredResource() AlertPathSelectorInfoTimeSerieMonitoredResource {
	return AlertPathSelectorInfoTimeSerieMonitoredResource{}
}

type AlertPathSelectorInfoTimeSerieKey struct{}

func (AlertPathSelectorInfoTimeSerieKey) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().Key().FieldPath(),
	}
}

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

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

type AlertPathSelectorInfoTimeSerieMetric struct{}

func (AlertPathSelectorInfoTimeSerieMetric) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().Metric().FieldPath(),
	}
}

func (s AlertPathSelectorInfoTimeSerieMetric) WithValue(value *common.Metric) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorInfoTimeSerieMetric) WithArrayOfValues(values []*common.Metric) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorInfoTimeSerieMetric) Type() AlertPathSelectorInfoTimeSerieMetricType {
	return AlertPathSelectorInfoTimeSerieMetricType{}
}

func (AlertPathSelectorInfoTimeSerieMetric) Labels() AlertPathSelectorInfoTimeSerieMetricLabels {
	return AlertPathSelectorInfoTimeSerieMetricLabels{}
}

func (AlertPathSelectorInfoTimeSerieMetric) ReducedLabels() AlertPathSelectorInfoTimeSerieMetricReducedLabels {
	return AlertPathSelectorInfoTimeSerieMetricReducedLabels{}
}

type AlertPathSelectorInfoTimeSerieMetricType struct{}

func (AlertPathSelectorInfoTimeSerieMetricType) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().Metric().Type().FieldPath(),
	}
}

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

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

type AlertPathSelectorInfoTimeSerieMetricLabels struct{}

func (AlertPathSelectorInfoTimeSerieMetricLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().Metric().Labels().FieldPath(),
	}
}

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

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

func (AlertPathSelectorInfoTimeSerieMetricLabels) WithKey(key string) AlertMapPathSelectorInfoTimeSerieMetricLabels {
	return AlertMapPathSelectorInfoTimeSerieMetricLabels{key: key}
}

type AlertMapPathSelectorInfoTimeSerieMetricLabels struct {
	key string
}

func (s AlertMapPathSelectorInfoTimeSerieMetricLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().Metric().Labels().WithKey(s.key).FieldPath(),
	}
}

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

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

type AlertPathSelectorInfoTimeSerieMetricReducedLabels struct{}

func (AlertPathSelectorInfoTimeSerieMetricReducedLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().Metric().ReducedLabels().FieldPath(),
	}
}

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

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

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

type AlertPathSelectorInfoTimeSerieMonitoredResource struct{}

func (AlertPathSelectorInfoTimeSerieMonitoredResource) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().MonitoredResource().FieldPath(),
	}
}

func (s AlertPathSelectorInfoTimeSerieMonitoredResource) WithValue(value *common.MonitoredResource) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorInfoTimeSerieMonitoredResource) WithArrayOfValues(values []*common.MonitoredResource) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorInfoTimeSerieMonitoredResource) Type() AlertPathSelectorInfoTimeSerieMonitoredResourceType {
	return AlertPathSelectorInfoTimeSerieMonitoredResourceType{}
}

func (AlertPathSelectorInfoTimeSerieMonitoredResource) Labels() AlertPathSelectorInfoTimeSerieMonitoredResourceLabels {
	return AlertPathSelectorInfoTimeSerieMonitoredResourceLabels{}
}

func (AlertPathSelectorInfoTimeSerieMonitoredResource) ReducedLabels() AlertPathSelectorInfoTimeSerieMonitoredResourceReducedLabels {
	return AlertPathSelectorInfoTimeSerieMonitoredResourceReducedLabels{}
}

type AlertPathSelectorInfoTimeSerieMonitoredResourceType struct{}

func (AlertPathSelectorInfoTimeSerieMonitoredResourceType) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().MonitoredResource().Type().FieldPath(),
	}
}

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

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

type AlertPathSelectorInfoTimeSerieMonitoredResourceLabels struct{}

func (AlertPathSelectorInfoTimeSerieMonitoredResourceLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().MonitoredResource().Labels().FieldPath(),
	}
}

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

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

func (AlertPathSelectorInfoTimeSerieMonitoredResourceLabels) WithKey(key string) AlertMapPathSelectorInfoTimeSerieMonitoredResourceLabels {
	return AlertMapPathSelectorInfoTimeSerieMonitoredResourceLabels{key: key}
}

type AlertMapPathSelectorInfoTimeSerieMonitoredResourceLabels struct {
	key string
}

func (s AlertMapPathSelectorInfoTimeSerieMonitoredResourceLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().MonitoredResource().Labels().WithKey(s.key).FieldPath(),
	}
}

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

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

type AlertPathSelectorInfoTimeSerieMonitoredResourceReducedLabels struct{}

func (AlertPathSelectorInfoTimeSerieMonitoredResourceReducedLabels) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().TimeSerie().MonitoredResource().ReducedLabels().FieldPath(),
	}
}

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

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

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

type AlertPathSelectorInfoObservedValues struct{}

func (AlertPathSelectorInfoObservedValues) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().ObservedValues().FieldPath(),
	}
}

func (s AlertPathSelectorInfoObservedValues) WithValue(value *Alert_Info_ObservedValues) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

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

func (AlertPathSelectorInfoObservedValues) ExampleValue() AlertPathSelectorInfoObservedValuesExampleValue {
	return AlertPathSelectorInfoObservedValuesExampleValue{}
}

func (AlertPathSelectorInfoObservedValues) PerMetric() AlertPathSelectorInfoObservedValuesPerMetric {
	return AlertPathSelectorInfoObservedValuesPerMetric{}
}

type AlertPathSelectorInfoObservedValuesExampleValue struct{}

func (AlertPathSelectorInfoObservedValuesExampleValue) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().ObservedValues().ExampleValue().FieldPath(),
	}
}

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

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

type AlertPathSelectorInfoObservedValuesPerMetric struct{}

func (AlertPathSelectorInfoObservedValuesPerMetric) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().ObservedValues().PerMetric().FieldPath(),
	}
}

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

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

func (AlertPathSelectorInfoObservedValuesPerMetric) WithKey(key string) AlertMapPathSelectorInfoObservedValuesPerMetric {
	return AlertMapPathSelectorInfoObservedValuesPerMetric{key: key}
}

type AlertMapPathSelectorInfoObservedValuesPerMetric struct {
	key string
}

func (s AlertMapPathSelectorInfoObservedValuesPerMetric) FieldPath() *Alert_FieldSubPath {
	return &Alert_FieldSubPath{
		selector: Alert_FieldPathSelectorInfo,
		subPath:  NewAlertInfoFieldPathBuilder().ObservedValues().PerMetric().WithKey(s.key).FieldPath(),
	}
}

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

func (s AlertMapPathSelectorInfoObservedValuesPerMetric) WithArrayOfValues(values []float64) *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) IsAcknowledged() AlertPathSelectorStateIsAcknowledged {
	return AlertPathSelectorStateIsAcknowledged{}
}

func (AlertPathSelectorState) IsSilenced() AlertPathSelectorStateIsSilenced {
	return AlertPathSelectorStateIsSilenced{}
}

func (AlertPathSelectorState) Lifetime() AlertPathSelectorStateLifetime {
	return AlertPathSelectorStateLifetime{}
}

func (AlertPathSelectorState) NeedsNotification() AlertPathSelectorStateNeedsNotification {
	return AlertPathSelectorStateNeedsNotification{}
}

func (AlertPathSelectorState) NotificationCreated() AlertPathSelectorStateNotificationCreated {
	return AlertPathSelectorStateNotificationCreated{}
}

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 AlertPathSelectorStateIsAcknowledged struct{}

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

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

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

type AlertPathSelectorStateIsSilenced struct{}

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

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

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

type AlertPathSelectorStateLifetime struct{}

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

func (s AlertPathSelectorStateLifetime) WithValue(value *common.TimeRange) *Alert_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Alert_FieldSubPathValue)
}

func (s AlertPathSelectorStateLifetime) WithArrayOfValues(values []*common.TimeRange) *Alert_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Alert_FieldSubPathArrayOfValues)
}

func (AlertPathSelectorStateLifetime) StartTime() AlertPathSelectorStateLifetimeStartTime {
	return AlertPathSelectorStateLifetimeStartTime{}
}

func (AlertPathSelectorStateLifetime) EndTime() AlertPathSelectorStateLifetimeEndTime {
	return AlertPathSelectorStateLifetimeEndTime{}
}

type AlertPathSelectorStateLifetimeStartTime struct{}

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

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

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

type AlertPathSelectorStateLifetimeEndTime struct{}

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

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

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

type AlertPathSelectorStateNeedsNotification struct{}

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

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

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

type AlertPathSelectorStateNotificationCreated struct{}

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

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

func (s AlertPathSelectorStateNotificationCreated) WithArrayOfValues(values []bool) *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 AlertInfoFieldPathBuilder struct{}

func NewAlertInfoFieldPathBuilder() AlertInfoFieldPathBuilder {
	return AlertInfoFieldPathBuilder{}
}
func (AlertInfoFieldPathBuilder) TimeSerie() Alert_InfoPathSelectorTimeSerie {
	return Alert_InfoPathSelectorTimeSerie{}
}
func (AlertInfoFieldPathBuilder) ObservedValues() Alert_InfoPathSelectorObservedValues {
	return Alert_InfoPathSelectorObservedValues{}
}

type Alert_InfoPathSelectorTimeSerie struct{}

func (Alert_InfoPathSelectorTimeSerie) FieldPath() *AlertInfo_FieldTerminalPath {
	return &AlertInfo_FieldTerminalPath{selector: AlertInfo_FieldPathSelectorTimeSerie}
}

func (s Alert_InfoPathSelectorTimeSerie) WithValue(value *Alert_Info_TimeSerie) *AlertInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldTerminalPathValue)
}

func (s Alert_InfoPathSelectorTimeSerie) WithArrayOfValues(values []*Alert_Info_TimeSerie) *AlertInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfo_FieldTerminalPathArrayOfValues)
}

func (Alert_InfoPathSelectorTimeSerie) WithSubPath(subPath AlertInfoTimeSerie_FieldPath) *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{selector: AlertInfo_FieldPathSelectorTimeSerie, subPath: subPath}
}

func (s Alert_InfoPathSelectorTimeSerie) WithSubValue(subPathValue AlertInfoTimeSerie_FieldPathValue) *AlertInfo_FieldSubPathValue {
	return &AlertInfo_FieldSubPathValue{AlertInfo_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_InfoPathSelectorTimeSerie) WithSubArrayOfValues(subPathArrayOfValues AlertInfoTimeSerie_FieldPathArrayOfValues) *AlertInfo_FieldSubPathArrayOfValues {
	return &AlertInfo_FieldSubPathArrayOfValues{AlertInfo_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_InfoPathSelectorTimeSerie) WithSubArrayItemValue(subPathArrayItemValue AlertInfoTimeSerie_FieldPathArrayItemValue) *AlertInfo_FieldSubPathArrayItemValue {
	return &AlertInfo_FieldSubPathArrayItemValue{AlertInfo_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_InfoPathSelectorTimeSerie) Key() Alert_InfoPathSelectorTimeSerieKey {
	return Alert_InfoPathSelectorTimeSerieKey{}
}

func (Alert_InfoPathSelectorTimeSerie) Metric() Alert_InfoPathSelectorTimeSerieMetric {
	return Alert_InfoPathSelectorTimeSerieMetric{}
}

func (Alert_InfoPathSelectorTimeSerie) MonitoredResource() Alert_InfoPathSelectorTimeSerieMonitoredResource {
	return Alert_InfoPathSelectorTimeSerieMonitoredResource{}
}

type Alert_InfoPathSelectorTimeSerieKey struct{}

func (Alert_InfoPathSelectorTimeSerieKey) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().Key().FieldPath(),
	}
}

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

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

type Alert_InfoPathSelectorTimeSerieMetric struct{}

func (Alert_InfoPathSelectorTimeSerieMetric) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().Metric().FieldPath(),
	}
}

func (s Alert_InfoPathSelectorTimeSerieMetric) WithValue(value *common.Metric) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

func (s Alert_InfoPathSelectorTimeSerieMetric) WithArrayOfValues(values []*common.Metric) *AlertInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfo_FieldSubPathArrayOfValues)
}

func (Alert_InfoPathSelectorTimeSerieMetric) Type() Alert_InfoPathSelectorTimeSerieMetricType {
	return Alert_InfoPathSelectorTimeSerieMetricType{}
}

func (Alert_InfoPathSelectorTimeSerieMetric) Labels() Alert_InfoPathSelectorTimeSerieMetricLabels {
	return Alert_InfoPathSelectorTimeSerieMetricLabels{}
}

func (Alert_InfoPathSelectorTimeSerieMetric) ReducedLabels() Alert_InfoPathSelectorTimeSerieMetricReducedLabels {
	return Alert_InfoPathSelectorTimeSerieMetricReducedLabels{}
}

type Alert_InfoPathSelectorTimeSerieMetricType struct{}

func (Alert_InfoPathSelectorTimeSerieMetricType) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().Metric().Type().FieldPath(),
	}
}

func (s Alert_InfoPathSelectorTimeSerieMetricType) WithValue(value string) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

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

type Alert_InfoPathSelectorTimeSerieMetricLabels struct{}

func (Alert_InfoPathSelectorTimeSerieMetricLabels) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().Metric().Labels().FieldPath(),
	}
}

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

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

func (Alert_InfoPathSelectorTimeSerieMetricLabels) WithKey(key string) Alert_InfoMapPathSelectorTimeSerieMetricLabels {
	return Alert_InfoMapPathSelectorTimeSerieMetricLabels{key: key}
}

type Alert_InfoMapPathSelectorTimeSerieMetricLabels struct {
	key string
}

func (s Alert_InfoMapPathSelectorTimeSerieMetricLabels) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().Metric().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s Alert_InfoMapPathSelectorTimeSerieMetricLabels) WithValue(value string) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

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

type Alert_InfoPathSelectorTimeSerieMetricReducedLabels struct{}

func (Alert_InfoPathSelectorTimeSerieMetricReducedLabels) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().Metric().ReducedLabels().FieldPath(),
	}
}

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

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

func (s Alert_InfoPathSelectorTimeSerieMetricReducedLabels) WithItemValue(value string) *AlertInfo_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertInfo_FieldSubPathArrayItemValue)
}

type Alert_InfoPathSelectorTimeSerieMonitoredResource struct{}

func (Alert_InfoPathSelectorTimeSerieMonitoredResource) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().MonitoredResource().FieldPath(),
	}
}

func (s Alert_InfoPathSelectorTimeSerieMonitoredResource) WithValue(value *common.MonitoredResource) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

func (s Alert_InfoPathSelectorTimeSerieMonitoredResource) WithArrayOfValues(values []*common.MonitoredResource) *AlertInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfo_FieldSubPathArrayOfValues)
}

func (Alert_InfoPathSelectorTimeSerieMonitoredResource) Type() Alert_InfoPathSelectorTimeSerieMonitoredResourceType {
	return Alert_InfoPathSelectorTimeSerieMonitoredResourceType{}
}

func (Alert_InfoPathSelectorTimeSerieMonitoredResource) Labels() Alert_InfoPathSelectorTimeSerieMonitoredResourceLabels {
	return Alert_InfoPathSelectorTimeSerieMonitoredResourceLabels{}
}

func (Alert_InfoPathSelectorTimeSerieMonitoredResource) ReducedLabels() Alert_InfoPathSelectorTimeSerieMonitoredResourceReducedLabels {
	return Alert_InfoPathSelectorTimeSerieMonitoredResourceReducedLabels{}
}

type Alert_InfoPathSelectorTimeSerieMonitoredResourceType struct{}

func (Alert_InfoPathSelectorTimeSerieMonitoredResourceType) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().MonitoredResource().Type().FieldPath(),
	}
}

func (s Alert_InfoPathSelectorTimeSerieMonitoredResourceType) WithValue(value string) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

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

type Alert_InfoPathSelectorTimeSerieMonitoredResourceLabels struct{}

func (Alert_InfoPathSelectorTimeSerieMonitoredResourceLabels) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().MonitoredResource().Labels().FieldPath(),
	}
}

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

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

func (Alert_InfoPathSelectorTimeSerieMonitoredResourceLabels) WithKey(key string) Alert_InfoMapPathSelectorTimeSerieMonitoredResourceLabels {
	return Alert_InfoMapPathSelectorTimeSerieMonitoredResourceLabels{key: key}
}

type Alert_InfoMapPathSelectorTimeSerieMonitoredResourceLabels struct {
	key string
}

func (s Alert_InfoMapPathSelectorTimeSerieMonitoredResourceLabels) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().MonitoredResource().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s Alert_InfoMapPathSelectorTimeSerieMonitoredResourceLabels) WithValue(value string) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

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

type Alert_InfoPathSelectorTimeSerieMonitoredResourceReducedLabels struct{}

func (Alert_InfoPathSelectorTimeSerieMonitoredResourceReducedLabels) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorTimeSerie,
		subPath:  NewAlertInfoTimeSerieFieldPathBuilder().MonitoredResource().ReducedLabels().FieldPath(),
	}
}

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

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

func (s Alert_InfoPathSelectorTimeSerieMonitoredResourceReducedLabels) WithItemValue(value string) *AlertInfo_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertInfo_FieldSubPathArrayItemValue)
}

type Alert_InfoPathSelectorObservedValues struct{}

func (Alert_InfoPathSelectorObservedValues) FieldPath() *AlertInfo_FieldTerminalPath {
	return &AlertInfo_FieldTerminalPath{selector: AlertInfo_FieldPathSelectorObservedValues}
}

func (s Alert_InfoPathSelectorObservedValues) WithValue(value *Alert_Info_ObservedValues) *AlertInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldTerminalPathValue)
}

func (s Alert_InfoPathSelectorObservedValues) WithArrayOfValues(values []*Alert_Info_ObservedValues) *AlertInfo_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfo_FieldTerminalPathArrayOfValues)
}

func (Alert_InfoPathSelectorObservedValues) WithSubPath(subPath AlertInfoObservedValues_FieldPath) *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{selector: AlertInfo_FieldPathSelectorObservedValues, subPath: subPath}
}

func (s Alert_InfoPathSelectorObservedValues) WithSubValue(subPathValue AlertInfoObservedValues_FieldPathValue) *AlertInfo_FieldSubPathValue {
	return &AlertInfo_FieldSubPathValue{AlertInfo_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_InfoPathSelectorObservedValues) WithSubArrayOfValues(subPathArrayOfValues AlertInfoObservedValues_FieldPathArrayOfValues) *AlertInfo_FieldSubPathArrayOfValues {
	return &AlertInfo_FieldSubPathArrayOfValues{AlertInfo_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_InfoPathSelectorObservedValues) WithSubArrayItemValue(subPathArrayItemValue AlertInfoObservedValues_FieldPathArrayItemValue) *AlertInfo_FieldSubPathArrayItemValue {
	return &AlertInfo_FieldSubPathArrayItemValue{AlertInfo_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_InfoPathSelectorObservedValues) ExampleValue() Alert_InfoPathSelectorObservedValuesExampleValue {
	return Alert_InfoPathSelectorObservedValuesExampleValue{}
}

func (Alert_InfoPathSelectorObservedValues) PerMetric() Alert_InfoPathSelectorObservedValuesPerMetric {
	return Alert_InfoPathSelectorObservedValuesPerMetric{}
}

type Alert_InfoPathSelectorObservedValuesExampleValue struct{}

func (Alert_InfoPathSelectorObservedValuesExampleValue) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorObservedValues,
		subPath:  NewAlertInfoObservedValuesFieldPathBuilder().ExampleValue().FieldPath(),
	}
}

func (s Alert_InfoPathSelectorObservedValuesExampleValue) WithValue(value float64) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

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

type Alert_InfoPathSelectorObservedValuesPerMetric struct{}

func (Alert_InfoPathSelectorObservedValuesPerMetric) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorObservedValues,
		subPath:  NewAlertInfoObservedValuesFieldPathBuilder().PerMetric().FieldPath(),
	}
}

func (s Alert_InfoPathSelectorObservedValuesPerMetric) WithValue(value map[string]float64) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

func (s Alert_InfoPathSelectorObservedValuesPerMetric) WithArrayOfValues(values []map[string]float64) *AlertInfo_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfo_FieldSubPathArrayOfValues)
}

func (Alert_InfoPathSelectorObservedValuesPerMetric) WithKey(key string) Alert_InfoMapPathSelectorObservedValuesPerMetric {
	return Alert_InfoMapPathSelectorObservedValuesPerMetric{key: key}
}

type Alert_InfoMapPathSelectorObservedValuesPerMetric struct {
	key string
}

func (s Alert_InfoMapPathSelectorObservedValuesPerMetric) FieldPath() *AlertInfo_FieldSubPath {
	return &AlertInfo_FieldSubPath{
		selector: AlertInfo_FieldPathSelectorObservedValues,
		subPath:  NewAlertInfoObservedValuesFieldPathBuilder().PerMetric().WithKey(s.key).FieldPath(),
	}
}

func (s Alert_InfoMapPathSelectorObservedValuesPerMetric) WithValue(value float64) *AlertInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfo_FieldSubPathValue)
}

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

type AlertStateFieldPathBuilder struct{}

func NewAlertStateFieldPathBuilder() AlertStateFieldPathBuilder {
	return AlertStateFieldPathBuilder{}
}
func (AlertStateFieldPathBuilder) IsFiring() Alert_StatePathSelectorIsFiring {
	return Alert_StatePathSelectorIsFiring{}
}
func (AlertStateFieldPathBuilder) IsAcknowledged() Alert_StatePathSelectorIsAcknowledged {
	return Alert_StatePathSelectorIsAcknowledged{}
}
func (AlertStateFieldPathBuilder) IsSilenced() Alert_StatePathSelectorIsSilenced {
	return Alert_StatePathSelectorIsSilenced{}
}
func (AlertStateFieldPathBuilder) Lifetime() Alert_StatePathSelectorLifetime {
	return Alert_StatePathSelectorLifetime{}
}
func (AlertStateFieldPathBuilder) NeedsNotification() Alert_StatePathSelectorNeedsNotification {
	return Alert_StatePathSelectorNeedsNotification{}
}
func (AlertStateFieldPathBuilder) NotificationCreated() Alert_StatePathSelectorNotificationCreated {
	return Alert_StatePathSelectorNotificationCreated{}
}
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_StatePathSelectorIsAcknowledged struct{}

func (Alert_StatePathSelectorIsAcknowledged) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsAcknowledged}
}

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

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

type Alert_StatePathSelectorIsSilenced struct{}

func (Alert_StatePathSelectorIsSilenced) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsSilenced}
}

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

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

type Alert_StatePathSelectorLifetime struct{}

func (Alert_StatePathSelectorLifetime) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifetime}
}

func (s Alert_StatePathSelectorLifetime) WithValue(value *common.TimeRange) *AlertState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldTerminalPathValue)
}

func (s Alert_StatePathSelectorLifetime) WithArrayOfValues(values []*common.TimeRange) *AlertState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertState_FieldTerminalPathArrayOfValues)
}

func (Alert_StatePathSelectorLifetime) WithSubPath(subPath common.TimeRange_FieldPath) *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorLifetime, subPath: subPath}
}

func (s Alert_StatePathSelectorLifetime) WithSubValue(subPathValue common.TimeRange_FieldPathValue) *AlertState_FieldSubPathValue {
	return &AlertState_FieldSubPathValue{AlertState_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_StatePathSelectorLifetime) WithSubArrayOfValues(subPathArrayOfValues common.TimeRange_FieldPathArrayOfValues) *AlertState_FieldSubPathArrayOfValues {
	return &AlertState_FieldSubPathArrayOfValues{AlertState_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_StatePathSelectorLifetime) WithSubArrayItemValue(subPathArrayItemValue common.TimeRange_FieldPathArrayItemValue) *AlertState_FieldSubPathArrayItemValue {
	return &AlertState_FieldSubPathArrayItemValue{AlertState_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_StatePathSelectorLifetime) StartTime() Alert_StatePathSelectorLifetimeStartTime {
	return Alert_StatePathSelectorLifetimeStartTime{}
}

func (Alert_StatePathSelectorLifetime) EndTime() Alert_StatePathSelectorLifetimeEndTime {
	return Alert_StatePathSelectorLifetimeEndTime{}
}

type Alert_StatePathSelectorLifetimeStartTime struct{}

func (Alert_StatePathSelectorLifetimeStartTime) FieldPath() *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{
		selector: AlertState_FieldPathSelectorLifetime,
		subPath:  common.NewTimeRangeFieldPathBuilder().StartTime().FieldPath(),
	}
}

func (s Alert_StatePathSelectorLifetimeStartTime) WithValue(value *timestamppb.Timestamp) *AlertState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldSubPathValue)
}

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

type Alert_StatePathSelectorLifetimeEndTime struct{}

func (Alert_StatePathSelectorLifetimeEndTime) FieldPath() *AlertState_FieldSubPath {
	return &AlertState_FieldSubPath{
		selector: AlertState_FieldPathSelectorLifetime,
		subPath:  common.NewTimeRangeFieldPathBuilder().EndTime().FieldPath(),
	}
}

func (s Alert_StatePathSelectorLifetimeEndTime) WithValue(value *timestamppb.Timestamp) *AlertState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertState_FieldSubPathValue)
}

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

type Alert_StatePathSelectorNeedsNotification struct{}

func (Alert_StatePathSelectorNeedsNotification) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNeedsNotification}
}

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

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

type Alert_StatePathSelectorNotificationCreated struct{}

func (Alert_StatePathSelectorNotificationCreated) FieldPath() *AlertState_FieldTerminalPath {
	return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationCreated}
}

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

func (s Alert_StatePathSelectorNotificationCreated) WithArrayOfValues(values []bool) *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 AlertInfoTimeSerieFieldPathBuilder struct{}

func NewAlertInfoTimeSerieFieldPathBuilder() AlertInfoTimeSerieFieldPathBuilder {
	return AlertInfoTimeSerieFieldPathBuilder{}
}
func (AlertInfoTimeSerieFieldPathBuilder) Key() Alert_Info_TimeSeriePathSelectorKey {
	return Alert_Info_TimeSeriePathSelectorKey{}
}
func (AlertInfoTimeSerieFieldPathBuilder) Metric() Alert_Info_TimeSeriePathSelectorMetric {
	return Alert_Info_TimeSeriePathSelectorMetric{}
}
func (AlertInfoTimeSerieFieldPathBuilder) MonitoredResource() Alert_Info_TimeSeriePathSelectorMonitoredResource {
	return Alert_Info_TimeSeriePathSelectorMonitoredResource{}
}

type Alert_Info_TimeSeriePathSelectorKey struct{}

func (Alert_Info_TimeSeriePathSelectorKey) FieldPath() *AlertInfoTimeSerie_FieldTerminalPath {
	return &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorKey}
}

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

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

type Alert_Info_TimeSeriePathSelectorMetric struct{}

func (Alert_Info_TimeSeriePathSelectorMetric) FieldPath() *AlertInfoTimeSerie_FieldTerminalPath {
	return &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorMetric}
}

func (s Alert_Info_TimeSeriePathSelectorMetric) WithValue(value *common.Metric) *AlertInfoTimeSerie_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoTimeSerie_FieldTerminalPathValue)
}

func (s Alert_Info_TimeSeriePathSelectorMetric) WithArrayOfValues(values []*common.Metric) *AlertInfoTimeSerie_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfoTimeSerie_FieldTerminalPathArrayOfValues)
}

func (Alert_Info_TimeSeriePathSelectorMetric) WithSubPath(subPath common.Metric_FieldPath) *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{selector: AlertInfoTimeSerie_FieldPathSelectorMetric, subPath: subPath}
}

func (s Alert_Info_TimeSeriePathSelectorMetric) WithSubValue(subPathValue common.Metric_FieldPathValue) *AlertInfoTimeSerie_FieldSubPathValue {
	return &AlertInfoTimeSerie_FieldSubPathValue{AlertInfoTimeSerie_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_Info_TimeSeriePathSelectorMetric) WithSubArrayOfValues(subPathArrayOfValues common.Metric_FieldPathArrayOfValues) *AlertInfoTimeSerie_FieldSubPathArrayOfValues {
	return &AlertInfoTimeSerie_FieldSubPathArrayOfValues{AlertInfoTimeSerie_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_Info_TimeSeriePathSelectorMetric) WithSubArrayItemValue(subPathArrayItemValue common.Metric_FieldPathArrayItemValue) *AlertInfoTimeSerie_FieldSubPathArrayItemValue {
	return &AlertInfoTimeSerie_FieldSubPathArrayItemValue{AlertInfoTimeSerie_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_Info_TimeSeriePathSelectorMetric) Type() Alert_Info_TimeSeriePathSelectorMetricType {
	return Alert_Info_TimeSeriePathSelectorMetricType{}
}

func (Alert_Info_TimeSeriePathSelectorMetric) Labels() Alert_Info_TimeSeriePathSelectorMetricLabels {
	return Alert_Info_TimeSeriePathSelectorMetricLabels{}
}

func (Alert_Info_TimeSeriePathSelectorMetric) ReducedLabels() Alert_Info_TimeSeriePathSelectorMetricReducedLabels {
	return Alert_Info_TimeSeriePathSelectorMetricReducedLabels{}
}

type Alert_Info_TimeSeriePathSelectorMetricType struct{}

func (Alert_Info_TimeSeriePathSelectorMetricType) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMetric,
		subPath:  common.NewMetricFieldPathBuilder().Type().FieldPath(),
	}
}

func (s Alert_Info_TimeSeriePathSelectorMetricType) WithValue(value string) *AlertInfoTimeSerie_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoTimeSerie_FieldSubPathValue)
}

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

type Alert_Info_TimeSeriePathSelectorMetricLabels struct{}

func (Alert_Info_TimeSeriePathSelectorMetricLabels) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMetric,
		subPath:  common.NewMetricFieldPathBuilder().Labels().FieldPath(),
	}
}

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

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

func (Alert_Info_TimeSeriePathSelectorMetricLabels) WithKey(key string) Alert_Info_TimeSerieMapPathSelectorMetricLabels {
	return Alert_Info_TimeSerieMapPathSelectorMetricLabels{key: key}
}

type Alert_Info_TimeSerieMapPathSelectorMetricLabels struct {
	key string
}

func (s Alert_Info_TimeSerieMapPathSelectorMetricLabels) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMetric,
		subPath:  common.NewMetricFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s Alert_Info_TimeSerieMapPathSelectorMetricLabels) WithValue(value string) *AlertInfoTimeSerie_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoTimeSerie_FieldSubPathValue)
}

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

type Alert_Info_TimeSeriePathSelectorMetricReducedLabels struct{}

func (Alert_Info_TimeSeriePathSelectorMetricReducedLabels) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMetric,
		subPath:  common.NewMetricFieldPathBuilder().ReducedLabels().FieldPath(),
	}
}

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

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

func (s Alert_Info_TimeSeriePathSelectorMetricReducedLabels) WithItemValue(value string) *AlertInfoTimeSerie_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertInfoTimeSerie_FieldSubPathArrayItemValue)
}

type Alert_Info_TimeSeriePathSelectorMonitoredResource struct{}

func (Alert_Info_TimeSeriePathSelectorMonitoredResource) FieldPath() *AlertInfoTimeSerie_FieldTerminalPath {
	return &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource}
}

func (s Alert_Info_TimeSeriePathSelectorMonitoredResource) WithValue(value *common.MonitoredResource) *AlertInfoTimeSerie_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoTimeSerie_FieldTerminalPathValue)
}

func (s Alert_Info_TimeSeriePathSelectorMonitoredResource) WithArrayOfValues(values []*common.MonitoredResource) *AlertInfoTimeSerie_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfoTimeSerie_FieldTerminalPathArrayOfValues)
}

func (Alert_Info_TimeSeriePathSelectorMonitoredResource) WithSubPath(subPath common.MonitoredResource_FieldPath) *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource, subPath: subPath}
}

func (s Alert_Info_TimeSeriePathSelectorMonitoredResource) WithSubValue(subPathValue common.MonitoredResource_FieldPathValue) *AlertInfoTimeSerie_FieldSubPathValue {
	return &AlertInfoTimeSerie_FieldSubPathValue{AlertInfoTimeSerie_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Alert_Info_TimeSeriePathSelectorMonitoredResource) WithSubArrayOfValues(subPathArrayOfValues common.MonitoredResource_FieldPathArrayOfValues) *AlertInfoTimeSerie_FieldSubPathArrayOfValues {
	return &AlertInfoTimeSerie_FieldSubPathArrayOfValues{AlertInfoTimeSerie_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Alert_Info_TimeSeriePathSelectorMonitoredResource) WithSubArrayItemValue(subPathArrayItemValue common.MonitoredResource_FieldPathArrayItemValue) *AlertInfoTimeSerie_FieldSubPathArrayItemValue {
	return &AlertInfoTimeSerie_FieldSubPathArrayItemValue{AlertInfoTimeSerie_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Alert_Info_TimeSeriePathSelectorMonitoredResource) Type() Alert_Info_TimeSeriePathSelectorMonitoredResourceType {
	return Alert_Info_TimeSeriePathSelectorMonitoredResourceType{}
}

func (Alert_Info_TimeSeriePathSelectorMonitoredResource) Labels() Alert_Info_TimeSeriePathSelectorMonitoredResourceLabels {
	return Alert_Info_TimeSeriePathSelectorMonitoredResourceLabels{}
}

func (Alert_Info_TimeSeriePathSelectorMonitoredResource) ReducedLabels() Alert_Info_TimeSeriePathSelectorMonitoredResourceReducedLabels {
	return Alert_Info_TimeSeriePathSelectorMonitoredResourceReducedLabels{}
}

type Alert_Info_TimeSeriePathSelectorMonitoredResourceType struct{}

func (Alert_Info_TimeSeriePathSelectorMonitoredResourceType) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource,
		subPath:  common.NewMonitoredResourceFieldPathBuilder().Type().FieldPath(),
	}
}

func (s Alert_Info_TimeSeriePathSelectorMonitoredResourceType) WithValue(value string) *AlertInfoTimeSerie_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoTimeSerie_FieldSubPathValue)
}

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

type Alert_Info_TimeSeriePathSelectorMonitoredResourceLabels struct{}

func (Alert_Info_TimeSeriePathSelectorMonitoredResourceLabels) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource,
		subPath:  common.NewMonitoredResourceFieldPathBuilder().Labels().FieldPath(),
	}
}

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

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

func (Alert_Info_TimeSeriePathSelectorMonitoredResourceLabels) WithKey(key string) Alert_Info_TimeSerieMapPathSelectorMonitoredResourceLabels {
	return Alert_Info_TimeSerieMapPathSelectorMonitoredResourceLabels{key: key}
}

type Alert_Info_TimeSerieMapPathSelectorMonitoredResourceLabels struct {
	key string
}

func (s Alert_Info_TimeSerieMapPathSelectorMonitoredResourceLabels) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource,
		subPath:  common.NewMonitoredResourceFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s Alert_Info_TimeSerieMapPathSelectorMonitoredResourceLabels) WithValue(value string) *AlertInfoTimeSerie_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoTimeSerie_FieldSubPathValue)
}

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

type Alert_Info_TimeSeriePathSelectorMonitoredResourceReducedLabels struct{}

func (Alert_Info_TimeSeriePathSelectorMonitoredResourceReducedLabels) FieldPath() *AlertInfoTimeSerie_FieldSubPath {
	return &AlertInfoTimeSerie_FieldSubPath{
		selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource,
		subPath:  common.NewMonitoredResourceFieldPathBuilder().ReducedLabels().FieldPath(),
	}
}

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

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

func (s Alert_Info_TimeSeriePathSelectorMonitoredResourceReducedLabels) WithItemValue(value string) *AlertInfoTimeSerie_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertInfoTimeSerie_FieldSubPathArrayItemValue)
}

type AlertInfoObservedValuesFieldPathBuilder struct{}

func NewAlertInfoObservedValuesFieldPathBuilder() AlertInfoObservedValuesFieldPathBuilder {
	return AlertInfoObservedValuesFieldPathBuilder{}
}
func (AlertInfoObservedValuesFieldPathBuilder) ExampleValue() Alert_Info_ObservedValuesPathSelectorExampleValue {
	return Alert_Info_ObservedValuesPathSelectorExampleValue{}
}
func (AlertInfoObservedValuesFieldPathBuilder) PerMetric() Alert_Info_ObservedValuesPathSelectorPerMetric {
	return Alert_Info_ObservedValuesPathSelectorPerMetric{}
}

type Alert_Info_ObservedValuesPathSelectorExampleValue struct{}

func (Alert_Info_ObservedValuesPathSelectorExampleValue) FieldPath() *AlertInfoObservedValues_FieldTerminalPath {
	return &AlertInfoObservedValues_FieldTerminalPath{selector: AlertInfoObservedValues_FieldPathSelectorExampleValue}
}

func (s Alert_Info_ObservedValuesPathSelectorExampleValue) WithValue(value float64) *AlertInfoObservedValues_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoObservedValues_FieldTerminalPathValue)
}

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

type Alert_Info_ObservedValuesPathSelectorPerMetric struct{}

func (Alert_Info_ObservedValuesPathSelectorPerMetric) FieldPath() *AlertInfoObservedValues_FieldTerminalPath {
	return &AlertInfoObservedValues_FieldTerminalPath{selector: AlertInfoObservedValues_FieldPathSelectorPerMetric}
}

func (s Alert_Info_ObservedValuesPathSelectorPerMetric) WithValue(value map[string]float64) *AlertInfoObservedValues_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoObservedValues_FieldTerminalPathValue)
}

func (s Alert_Info_ObservedValuesPathSelectorPerMetric) WithArrayOfValues(values []map[string]float64) *AlertInfoObservedValues_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertInfoObservedValues_FieldTerminalPathArrayOfValues)
}

func (Alert_Info_ObservedValuesPathSelectorPerMetric) WithKey(key string) Alert_Info_ObservedValuesMapPathSelectorPerMetric {
	return Alert_Info_ObservedValuesMapPathSelectorPerMetric{key: key}
}

type Alert_Info_ObservedValuesMapPathSelectorPerMetric struct {
	key string
}

func (s Alert_Info_ObservedValuesMapPathSelectorPerMetric) FieldPath() *AlertInfoObservedValues_FieldPathMap {
	return &AlertInfoObservedValues_FieldPathMap{selector: AlertInfoObservedValues_FieldPathSelectorPerMetric, key: s.key}
}

func (s Alert_Info_ObservedValuesMapPathSelectorPerMetric) WithValue(value float64) *AlertInfoObservedValues_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*AlertInfoObservedValues_FieldPathMapValue)
}

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

type AlertStateThresholdFieldPathBuilder struct{}

func NewAlertStateThresholdFieldPathBuilder() AlertStateThresholdFieldPathBuilder {
	return AlertStateThresholdFieldPathBuilder{}
}
func (AlertStateThresholdFieldPathBuilder) ObservedValue() Alert_State_ThresholdPathSelectorObservedValue {
	return Alert_State_ThresholdPathSelectorObservedValue{}
}

type Alert_State_ThresholdPathSelectorObservedValue struct{}

func (Alert_State_ThresholdPathSelectorObservedValue) FieldPath() *AlertStateThreshold_FieldTerminalPath {
	return &AlertStateThreshold_FieldTerminalPath{selector: AlertStateThreshold_FieldPathSelectorObservedValue}
}

func (s Alert_State_ThresholdPathSelectorObservedValue) WithValue(value float64) *AlertStateThreshold_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertStateThreshold_FieldTerminalPathValue)
}

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

type AlertStateCombineThresholdFieldPathBuilder struct{}

func NewAlertStateCombineThresholdFieldPathBuilder() AlertStateCombineThresholdFieldPathBuilder {
	return AlertStateCombineThresholdFieldPathBuilder{}
}

type AlertStateCombineThresholdPerMetricFieldPathBuilder struct{}

func NewAlertStateCombineThresholdPerMetricFieldPathBuilder() AlertStateCombineThresholdPerMetricFieldPathBuilder {
	return AlertStateCombineThresholdPerMetricFieldPathBuilder{}
}
func (AlertStateCombineThresholdPerMetricFieldPathBuilder) ObservedValues() Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues {
	return Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues{}
}

type Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues struct{}

func (Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues) FieldPath() *AlertStateCombineThresholdPerMetric_FieldTerminalPath {
	return &AlertStateCombineThresholdPerMetric_FieldTerminalPath{selector: AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues}
}

func (s Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues) WithValue(value map[string]float64) *AlertStateCombineThresholdPerMetric_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertStateCombineThresholdPerMetric_FieldTerminalPathValue)
}

func (s Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues) WithArrayOfValues(values []map[string]float64) *AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues)
}

func (Alert_State_CombineThreshold_PerMetricPathSelectorObservedValues) WithKey(key string) Alert_State_CombineThreshold_PerMetricMapPathSelectorObservedValues {
	return Alert_State_CombineThreshold_PerMetricMapPathSelectorObservedValues{key: key}
}

type Alert_State_CombineThreshold_PerMetricMapPathSelectorObservedValues struct {
	key string
}

func (s Alert_State_CombineThreshold_PerMetricMapPathSelectorObservedValues) FieldPath() *AlertStateCombineThresholdPerMetric_FieldPathMap {
	return &AlertStateCombineThresholdPerMetric_FieldPathMap{selector: AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues, key: s.key}
}

func (s Alert_State_CombineThreshold_PerMetricMapPathSelectorObservedValues) WithValue(value float64) *AlertStateCombineThresholdPerMetric_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*AlertStateCombineThresholdPerMetric_FieldPathMapValue)
}

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