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

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

package ts_entry

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

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

type TsEntryFieldPathBuilder struct{}

func NewTsEntryFieldPathBuilder() TsEntryFieldPathBuilder {
	return TsEntryFieldPathBuilder{}
}
func (TsEntryFieldPathBuilder) Name() TsEntryPathSelectorName {
	return TsEntryPathSelectorName{}
}
func (TsEntryFieldPathBuilder) Metadata() TsEntryPathSelectorMetadata {
	return TsEntryPathSelectorMetadata{}
}
func (TsEntryFieldPathBuilder) Info() TsEntryPathSelectorInfo {
	return TsEntryPathSelectorInfo{}
}
func (TsEntryFieldPathBuilder) State() TsEntryPathSelectorState {
	return TsEntryPathSelectorState{}
}
func (TsEntryFieldPathBuilder) Internal() TsEntryPathSelectorInternal {
	return TsEntryPathSelectorInternal{}
}

type TsEntryPathSelectorName struct{}

func (TsEntryPathSelectorName) FieldPath() *TsEntry_FieldTerminalPath {
	return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorName}
}

func (s TsEntryPathSelectorName) WithValue(value *Name) *TsEntry_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldTerminalPathValue)
}

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

type TsEntryPathSelectorMetadata struct{}

func (TsEntryPathSelectorMetadata) FieldPath() *TsEntry_FieldTerminalPath {
	return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorMetadata}
}

func (s TsEntryPathSelectorMetadata) WithValue(value *meta.Meta) *TsEntry_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldTerminalPathValue)
}

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

func (TsEntryPathSelectorMetadata) WithSubPath(subPath meta.Meta_FieldPath) *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorMetadata, subPath: subPath}
}

func (s TsEntryPathSelectorMetadata) WithSubValue(subPathValue meta.Meta_FieldPathValue) *TsEntry_FieldSubPathValue {
	return &TsEntry_FieldSubPathValue{TsEntry_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntryPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues meta.Meta_FieldPathArrayOfValues) *TsEntry_FieldSubPathArrayOfValues {
	return &TsEntry_FieldSubPathArrayOfValues{TsEntry_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntryPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue meta.Meta_FieldPathArrayItemValue) *TsEntry_FieldSubPathArrayItemValue {
	return &TsEntry_FieldSubPathArrayItemValue{TsEntry_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntryPathSelectorMetadata) CreateTime() TsEntryPathSelectorMetadataCreateTime {
	return TsEntryPathSelectorMetadataCreateTime{}
}

func (TsEntryPathSelectorMetadata) UpdateTime() TsEntryPathSelectorMetadataUpdateTime {
	return TsEntryPathSelectorMetadataUpdateTime{}
}

func (TsEntryPathSelectorMetadata) DeleteTime() TsEntryPathSelectorMetadataDeleteTime {
	return TsEntryPathSelectorMetadataDeleteTime{}
}

func (TsEntryPathSelectorMetadata) Uuid() TsEntryPathSelectorMetadataUuid {
	return TsEntryPathSelectorMetadataUuid{}
}

func (TsEntryPathSelectorMetadata) Tags() TsEntryPathSelectorMetadataTags {
	return TsEntryPathSelectorMetadataTags{}
}

func (TsEntryPathSelectorMetadata) Labels() TsEntryPathSelectorMetadataLabels {
	return TsEntryPathSelectorMetadataLabels{}
}

func (TsEntryPathSelectorMetadata) Annotations() TsEntryPathSelectorMetadataAnnotations {
	return TsEntryPathSelectorMetadataAnnotations{}
}

func (TsEntryPathSelectorMetadata) Generation() TsEntryPathSelectorMetadataGeneration {
	return TsEntryPathSelectorMetadataGeneration{}
}

func (TsEntryPathSelectorMetadata) ResourceVersion() TsEntryPathSelectorMetadataResourceVersion {
	return TsEntryPathSelectorMetadataResourceVersion{}
}

func (TsEntryPathSelectorMetadata) OwnerReferences() TsEntryPathSelectorMetadataOwnerReferences {
	return TsEntryPathSelectorMetadataOwnerReferences{}
}

func (TsEntryPathSelectorMetadata) Shards() TsEntryPathSelectorMetadataShards {
	return TsEntryPathSelectorMetadataShards{}
}

func (TsEntryPathSelectorMetadata) Syncing() TsEntryPathSelectorMetadataSyncing {
	return TsEntryPathSelectorMetadataSyncing{}
}

func (TsEntryPathSelectorMetadata) Lifecycle() TsEntryPathSelectorMetadataLifecycle {
	return TsEntryPathSelectorMetadataLifecycle{}
}

func (TsEntryPathSelectorMetadata) Services() TsEntryPathSelectorMetadataServices {
	return TsEntryPathSelectorMetadataServices{}
}

type TsEntryPathSelectorMetadataCreateTime struct{}

func (TsEntryPathSelectorMetadataCreateTime) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataCreateTime) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataUpdateTime struct{}

func (TsEntryPathSelectorMetadataUpdateTime) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataUpdateTime) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataDeleteTime struct{}

func (TsEntryPathSelectorMetadataDeleteTime) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataDeleteTime) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataUuid struct{}

func (TsEntryPathSelectorMetadataUuid) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataUuid) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataTags struct{}

func (TsEntryPathSelectorMetadataTags) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

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

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

func (s TsEntryPathSelectorMetadataTags) WithItemValue(value string) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

type TsEntryPathSelectorMetadataLabels struct{}

func (TsEntryPathSelectorMetadataLabels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

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

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

func (TsEntryPathSelectorMetadataLabels) WithKey(key string) TsEntryMapPathSelectorMetadataLabels {
	return TsEntryMapPathSelectorMetadataLabels{key: key}
}

type TsEntryMapPathSelectorMetadataLabels struct {
	key string
}

func (s TsEntryMapPathSelectorMetadataLabels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s TsEntryMapPathSelectorMetadataLabels) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataAnnotations struct{}

func (TsEntryPathSelectorMetadataAnnotations) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

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

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

func (TsEntryPathSelectorMetadataAnnotations) WithKey(key string) TsEntryMapPathSelectorMetadataAnnotations {
	return TsEntryMapPathSelectorMetadataAnnotations{key: key}
}

type TsEntryMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s TsEntryMapPathSelectorMetadataAnnotations) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s TsEntryMapPathSelectorMetadataAnnotations) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataGeneration struct{}

func (TsEntryPathSelectorMetadataGeneration) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataGeneration) WithValue(value int64) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataResourceVersion struct{}

func (TsEntryPathSelectorMetadataResourceVersion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataResourceVersion) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferences struct{}

func (TsEntryPathSelectorMetadataOwnerReferences) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

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

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

func (s TsEntryPathSelectorMetadataOwnerReferences) WithItemValue(value *meta.OwnerReference) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

func (TsEntryPathSelectorMetadataOwnerReferences) Kind() TsEntryPathSelectorMetadataOwnerReferencesKind {
	return TsEntryPathSelectorMetadataOwnerReferencesKind{}
}

func (TsEntryPathSelectorMetadataOwnerReferences) Version() TsEntryPathSelectorMetadataOwnerReferencesVersion {
	return TsEntryPathSelectorMetadataOwnerReferencesVersion{}
}

func (TsEntryPathSelectorMetadataOwnerReferences) Name() TsEntryPathSelectorMetadataOwnerReferencesName {
	return TsEntryPathSelectorMetadataOwnerReferencesName{}
}

func (TsEntryPathSelectorMetadataOwnerReferences) Region() TsEntryPathSelectorMetadataOwnerReferencesRegion {
	return TsEntryPathSelectorMetadataOwnerReferencesRegion{}
}

func (TsEntryPathSelectorMetadataOwnerReferences) Controller() TsEntryPathSelectorMetadataOwnerReferencesController {
	return TsEntryPathSelectorMetadataOwnerReferencesController{}
}

func (TsEntryPathSelectorMetadataOwnerReferences) RequiresOwnerReference() TsEntryPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return TsEntryPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

func (TsEntryPathSelectorMetadataOwnerReferences) UnsetOnDelete() TsEntryPathSelectorMetadataOwnerReferencesUnsetOnDelete {
	return TsEntryPathSelectorMetadataOwnerReferencesUnsetOnDelete{}
}

type TsEntryPathSelectorMetadataOwnerReferencesKind struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesKind) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferencesVersion struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesVersion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferencesName struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesName) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesName) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferencesRegion struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesRegion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferencesController struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesController) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataOwnerReferencesUnsetOnDelete struct{}

func (TsEntryPathSelectorMetadataOwnerReferencesUnsetOnDelete) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().UnsetOnDelete().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataShards struct{}

func (TsEntryPathSelectorMetadataShards) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

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

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

func (TsEntryPathSelectorMetadataShards) WithKey(key string) TsEntryMapPathSelectorMetadataShards {
	return TsEntryMapPathSelectorMetadataShards{key: key}
}

type TsEntryMapPathSelectorMetadataShards struct {
	key string
}

func (s TsEntryMapPathSelectorMetadataShards) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s TsEntryMapPathSelectorMetadataShards) WithValue(value int64) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataSyncing struct{}

func (TsEntryPathSelectorMetadataSyncing) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataSyncing) WithValue(value *meta.SyncingMeta) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

func (TsEntryPathSelectorMetadataSyncing) OwningRegion() TsEntryPathSelectorMetadataSyncingOwningRegion {
	return TsEntryPathSelectorMetadataSyncingOwningRegion{}
}

func (TsEntryPathSelectorMetadataSyncing) Regions() TsEntryPathSelectorMetadataSyncingRegions {
	return TsEntryPathSelectorMetadataSyncingRegions{}
}

type TsEntryPathSelectorMetadataSyncingOwningRegion struct{}

func (TsEntryPathSelectorMetadataSyncingOwningRegion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataSyncingRegions struct{}

func (TsEntryPathSelectorMetadataSyncingRegions) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

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

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

func (s TsEntryPathSelectorMetadataSyncingRegions) WithItemValue(value string) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

type TsEntryPathSelectorMetadataLifecycle struct{}

func (TsEntryPathSelectorMetadataLifecycle) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataLifecycle) WithValue(value *meta.Lifecycle) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

func (TsEntryPathSelectorMetadataLifecycle) State() TsEntryPathSelectorMetadataLifecycleState {
	return TsEntryPathSelectorMetadataLifecycleState{}
}

func (TsEntryPathSelectorMetadataLifecycle) BlockDeletion() TsEntryPathSelectorMetadataLifecycleBlockDeletion {
	return TsEntryPathSelectorMetadataLifecycleBlockDeletion{}
}

type TsEntryPathSelectorMetadataLifecycleState struct{}

func (TsEntryPathSelectorMetadataLifecycleState) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataLifecycleState) WithValue(value meta.Lifecycle_State) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataLifecycleBlockDeletion struct{}

func (TsEntryPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataServices struct{}

func (TsEntryPathSelectorMetadataServices) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

func (TsEntryPathSelectorMetadataServices) OwningService() TsEntryPathSelectorMetadataServicesOwningService {
	return TsEntryPathSelectorMetadataServicesOwningService{}
}

func (TsEntryPathSelectorMetadataServices) AllowedServices() TsEntryPathSelectorMetadataServicesAllowedServices {
	return TsEntryPathSelectorMetadataServicesAllowedServices{}
}

type TsEntryPathSelectorMetadataServicesOwningService struct{}

func (TsEntryPathSelectorMetadataServicesOwningService) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().OwningService().FieldPath(),
	}
}

func (s TsEntryPathSelectorMetadataServicesOwningService) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorMetadataServicesAllowedServices struct{}

func (TsEntryPathSelectorMetadataServicesAllowedServices) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().AllowedServices().FieldPath(),
	}
}

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

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

func (s TsEntryPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

type TsEntryPathSelectorInfo struct{}

func (TsEntryPathSelectorInfo) FieldPath() *TsEntry_FieldTerminalPath {
	return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorInfo}
}

func (s TsEntryPathSelectorInfo) WithValue(value *TsEntry_Info) *TsEntry_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldTerminalPathValue)
}

func (s TsEntryPathSelectorInfo) WithArrayOfValues(values []*TsEntry_Info) *TsEntry_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldTerminalPathArrayOfValues)
}

func (TsEntryPathSelectorInfo) WithSubPath(subPath TsEntryInfo_FieldPath) *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorInfo, subPath: subPath}
}

func (s TsEntryPathSelectorInfo) WithSubValue(subPathValue TsEntryInfo_FieldPathValue) *TsEntry_FieldSubPathValue {
	return &TsEntry_FieldSubPathValue{TsEntry_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntryPathSelectorInfo) WithSubArrayOfValues(subPathArrayOfValues TsEntryInfo_FieldPathArrayOfValues) *TsEntry_FieldSubPathArrayOfValues {
	return &TsEntry_FieldSubPathArrayOfValues{TsEntry_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntryPathSelectorInfo) WithSubArrayItemValue(subPathArrayItemValue TsEntryInfo_FieldPathArrayItemValue) *TsEntry_FieldSubPathArrayItemValue {
	return &TsEntry_FieldSubPathArrayItemValue{TsEntry_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntryPathSelectorInfo) AlertingResource() TsEntryPathSelectorInfoAlertingResource {
	return TsEntryPathSelectorInfoAlertingResource{}
}

func (TsEntryPathSelectorInfo) GroupByKey() TsEntryPathSelectorInfoGroupByKey {
	return TsEntryPathSelectorInfoGroupByKey{}
}

func (TsEntryPathSelectorInfo) CommonMetricLabels() TsEntryPathSelectorInfoCommonMetricLabels {
	return TsEntryPathSelectorInfoCommonMetricLabels{}
}

func (TsEntryPathSelectorInfo) CommonResourceLabels() TsEntryPathSelectorInfoCommonResourceLabels {
	return TsEntryPathSelectorInfoCommonResourceLabels{}
}

type TsEntryPathSelectorInfoAlertingResource struct{}

func (TsEntryPathSelectorInfoAlertingResource) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResource) WithValue(value *meta.OwnerReference) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

func (TsEntryPathSelectorInfoAlertingResource) Kind() TsEntryPathSelectorInfoAlertingResourceKind {
	return TsEntryPathSelectorInfoAlertingResourceKind{}
}

func (TsEntryPathSelectorInfoAlertingResource) Version() TsEntryPathSelectorInfoAlertingResourceVersion {
	return TsEntryPathSelectorInfoAlertingResourceVersion{}
}

func (TsEntryPathSelectorInfoAlertingResource) Name() TsEntryPathSelectorInfoAlertingResourceName {
	return TsEntryPathSelectorInfoAlertingResourceName{}
}

func (TsEntryPathSelectorInfoAlertingResource) Region() TsEntryPathSelectorInfoAlertingResourceRegion {
	return TsEntryPathSelectorInfoAlertingResourceRegion{}
}

func (TsEntryPathSelectorInfoAlertingResource) Controller() TsEntryPathSelectorInfoAlertingResourceController {
	return TsEntryPathSelectorInfoAlertingResourceController{}
}

func (TsEntryPathSelectorInfoAlertingResource) RequiresOwnerReference() TsEntryPathSelectorInfoAlertingResourceRequiresOwnerReference {
	return TsEntryPathSelectorInfoAlertingResourceRequiresOwnerReference{}
}

func (TsEntryPathSelectorInfoAlertingResource) UnsetOnDelete() TsEntryPathSelectorInfoAlertingResourceUnsetOnDelete {
	return TsEntryPathSelectorInfoAlertingResourceUnsetOnDelete{}
}

type TsEntryPathSelectorInfoAlertingResourceKind struct{}

func (TsEntryPathSelectorInfoAlertingResourceKind) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().Kind().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceKind) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoAlertingResourceVersion struct{}

func (TsEntryPathSelectorInfoAlertingResourceVersion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().Version().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceVersion) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoAlertingResourceName struct{}

func (TsEntryPathSelectorInfoAlertingResourceName) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().Name().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceName) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoAlertingResourceRegion struct{}

func (TsEntryPathSelectorInfoAlertingResourceRegion) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().Region().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceRegion) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoAlertingResourceController struct{}

func (TsEntryPathSelectorInfoAlertingResourceController) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().Controller().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceController) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoAlertingResourceRequiresOwnerReference struct{}

func (TsEntryPathSelectorInfoAlertingResourceRequiresOwnerReference) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().RequiresOwnerReference().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceRequiresOwnerReference) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoAlertingResourceUnsetOnDelete struct{}

func (TsEntryPathSelectorInfoAlertingResourceUnsetOnDelete) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().AlertingResource().UnsetOnDelete().FieldPath(),
	}
}

func (s TsEntryPathSelectorInfoAlertingResourceUnsetOnDelete) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoGroupByKey struct{}

func (TsEntryPathSelectorInfoGroupByKey) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().GroupByKey().FieldPath(),
	}
}

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

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

type TsEntryPathSelectorInfoCommonMetricLabels struct{}

func (TsEntryPathSelectorInfoCommonMetricLabels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().CommonMetricLabels().FieldPath(),
	}
}

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

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

func (TsEntryPathSelectorInfoCommonMetricLabels) WithKey(key string) TsEntryMapPathSelectorInfoCommonMetricLabels {
	return TsEntryMapPathSelectorInfoCommonMetricLabels{key: key}
}

type TsEntryMapPathSelectorInfoCommonMetricLabels struct {
	key string
}

func (s TsEntryMapPathSelectorInfoCommonMetricLabels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().CommonMetricLabels().WithKey(s.key).FieldPath(),
	}
}

func (s TsEntryMapPathSelectorInfoCommonMetricLabels) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInfoCommonResourceLabels struct{}

func (TsEntryPathSelectorInfoCommonResourceLabels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().CommonResourceLabels().FieldPath(),
	}
}

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

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

func (TsEntryPathSelectorInfoCommonResourceLabels) WithKey(key string) TsEntryMapPathSelectorInfoCommonResourceLabels {
	return TsEntryMapPathSelectorInfoCommonResourceLabels{key: key}
}

type TsEntryMapPathSelectorInfoCommonResourceLabels struct {
	key string
}

func (s TsEntryMapPathSelectorInfoCommonResourceLabels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInfo,
		subPath:  NewTsEntryInfoFieldPathBuilder().CommonResourceLabels().WithKey(s.key).FieldPath(),
	}
}

func (s TsEntryMapPathSelectorInfoCommonResourceLabels) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorState struct{}

func (TsEntryPathSelectorState) FieldPath() *TsEntry_FieldTerminalPath {
	return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorState}
}

func (s TsEntryPathSelectorState) WithValue(value *TsEntry_State) *TsEntry_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldTerminalPathValue)
}

func (s TsEntryPathSelectorState) WithArrayOfValues(values []*TsEntry_State) *TsEntry_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldTerminalPathArrayOfValues)
}

func (TsEntryPathSelectorState) WithSubPath(subPath TsEntryState_FieldPath) *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorState, subPath: subPath}
}

func (s TsEntryPathSelectorState) WithSubValue(subPathValue TsEntryState_FieldPathValue) *TsEntry_FieldSubPathValue {
	return &TsEntry_FieldSubPathValue{TsEntry_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntryPathSelectorState) WithSubArrayOfValues(subPathArrayOfValues TsEntryState_FieldPathArrayOfValues) *TsEntry_FieldSubPathArrayOfValues {
	return &TsEntry_FieldSubPathArrayOfValues{TsEntry_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntryPathSelectorState) WithSubArrayItemValue(subPathArrayItemValue TsEntryState_FieldPathArrayItemValue) *TsEntry_FieldSubPathArrayItemValue {
	return &TsEntry_FieldSubPathArrayItemValue{TsEntry_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntryPathSelectorState) Models() TsEntryPathSelectorStateModels {
	return TsEntryPathSelectorStateModels{}
}

func (TsEntryPathSelectorState) Thresholds() TsEntryPathSelectorStateThresholds {
	return TsEntryPathSelectorStateThresholds{}
}

type TsEntryPathSelectorStateModels struct{}

func (TsEntryPathSelectorStateModels) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModels) WithValue(value []*TsEntry_State_AnomalyModelData) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

func (s TsEntryPathSelectorStateModels) WithArrayOfValues(values [][]*TsEntry_State_AnomalyModelData) *TsEntry_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldSubPathArrayOfValues)
}

func (s TsEntryPathSelectorStateModels) WithItemValue(value *TsEntry_State_AnomalyModelData) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

func (TsEntryPathSelectorStateModels) AnalysisWindow() TsEntryPathSelectorStateModelsAnalysisWindow {
	return TsEntryPathSelectorStateModelsAnalysisWindow{}
}

func (TsEntryPathSelectorStateModels) ModelData() TsEntryPathSelectorStateModelsModelData {
	return TsEntryPathSelectorStateModelsModelData{}
}

func (TsEntryPathSelectorStateModels) TrainingMeanErr() TsEntryPathSelectorStateModelsTrainingMeanErr {
	return TsEntryPathSelectorStateModelsTrainingMeanErr{}
}

func (TsEntryPathSelectorStateModels) TrainingMaxErr() TsEntryPathSelectorStateModelsTrainingMaxErr {
	return TsEntryPathSelectorStateModelsTrainingMaxErr{}
}

func (TsEntryPathSelectorStateModels) TrainedInEpochs() TsEntryPathSelectorStateModelsTrainedInEpochs {
	return TsEntryPathSelectorStateModelsTrainedInEpochs{}
}

func (TsEntryPathSelectorStateModels) TrainedIn() TsEntryPathSelectorStateModelsTrainedIn {
	return TsEntryPathSelectorStateModelsTrainedIn{}
}

func (TsEntryPathSelectorStateModels) TrainAfter() TsEntryPathSelectorStateModelsTrainAfter {
	return TsEntryPathSelectorStateModelsTrainAfter{}
}

func (TsEntryPathSelectorStateModels) TrainingPeriod() TsEntryPathSelectorStateModelsTrainingPeriod {
	return TsEntryPathSelectorStateModelsTrainingPeriod{}
}

func (TsEntryPathSelectorStateModels) Sensitiveness() TsEntryPathSelectorStateModelsSensitiveness {
	return TsEntryPathSelectorStateModelsSensitiveness{}
}

type TsEntryPathSelectorStateModelsAnalysisWindow struct{}

func (TsEntryPathSelectorStateModelsAnalysisWindow) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().AnalysisWindow().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsAnalysisWindow) WithValue(value *durationpb.Duration) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateModelsModelData struct{}

func (TsEntryPathSelectorStateModelsModelData) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().ModelData().FieldPath(),
	}
}

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

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

type TsEntryPathSelectorStateModelsTrainingMeanErr struct{}

func (TsEntryPathSelectorStateModelsTrainingMeanErr) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainingMeanErr().FieldPath(),
	}
}

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

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

func (s TsEntryPathSelectorStateModelsTrainingMeanErr) WithItemValue(value float64) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

type TsEntryPathSelectorStateModelsTrainingMaxErr struct{}

func (TsEntryPathSelectorStateModelsTrainingMaxErr) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainingMaxErr().FieldPath(),
	}
}

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

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

func (s TsEntryPathSelectorStateModelsTrainingMaxErr) WithItemValue(value float64) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

type TsEntryPathSelectorStateModelsTrainedInEpochs struct{}

func (TsEntryPathSelectorStateModelsTrainedInEpochs) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainedInEpochs().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsTrainedInEpochs) WithValue(value int32) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

func (s TsEntryPathSelectorStateModelsTrainedInEpochs) WithArrayOfValues(values []int32) *TsEntry_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldSubPathArrayOfValues)
}

type TsEntryPathSelectorStateModelsTrainedIn struct{}

func (TsEntryPathSelectorStateModelsTrainedIn) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainedIn().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsTrainedIn) WithValue(value *durationpb.Duration) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateModelsTrainAfter struct{}

func (TsEntryPathSelectorStateModelsTrainAfter) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainAfter().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsTrainAfter) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateModelsTrainingPeriod struct{}

func (TsEntryPathSelectorStateModelsTrainingPeriod) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainingPeriod().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsTrainingPeriod) WithValue(value *monitoring_common.TimeInterval) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

func (s TsEntryPathSelectorStateModelsTrainingPeriod) WithArrayOfValues(values []*monitoring_common.TimeInterval) *TsEntry_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldSubPathArrayOfValues)
}

func (TsEntryPathSelectorStateModelsTrainingPeriod) EndTime() TsEntryPathSelectorStateModelsTrainingPeriodEndTime {
	return TsEntryPathSelectorStateModelsTrainingPeriodEndTime{}
}

func (TsEntryPathSelectorStateModelsTrainingPeriod) StartTime() TsEntryPathSelectorStateModelsTrainingPeriodStartTime {
	return TsEntryPathSelectorStateModelsTrainingPeriodStartTime{}
}

type TsEntryPathSelectorStateModelsTrainingPeriodEndTime struct{}

func (TsEntryPathSelectorStateModelsTrainingPeriodEndTime) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainingPeriod().EndTime().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsTrainingPeriodEndTime) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateModelsTrainingPeriodStartTime struct{}

func (TsEntryPathSelectorStateModelsTrainingPeriodStartTime) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().TrainingPeriod().StartTime().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsTrainingPeriodStartTime) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateModelsSensitiveness struct{}

func (TsEntryPathSelectorStateModelsSensitiveness) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().Sensitiveness().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsSensitiveness) WithValue(value []*TsEntry_State_AnomalyModelSensitiveness) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

func (s TsEntryPathSelectorStateModelsSensitiveness) WithArrayOfValues(values [][]*TsEntry_State_AnomalyModelSensitiveness) *TsEntry_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldSubPathArrayOfValues)
}

func (s TsEntryPathSelectorStateModelsSensitiveness) WithItemValue(value *TsEntry_State_AnomalyModelSensitiveness) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

func (TsEntryPathSelectorStateModelsSensitiveness) QueryName() TsEntryPathSelectorStateModelsSensitivenessQueryName {
	return TsEntryPathSelectorStateModelsSensitivenessQueryName{}
}

func (TsEntryPathSelectorStateModelsSensitiveness) AnomalyThreshold() TsEntryPathSelectorStateModelsSensitivenessAnomalyThreshold {
	return TsEntryPathSelectorStateModelsSensitivenessAnomalyThreshold{}
}

type TsEntryPathSelectorStateModelsSensitivenessQueryName struct{}

func (TsEntryPathSelectorStateModelsSensitivenessQueryName) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().Sensitiveness().QueryName().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsSensitivenessQueryName) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateModelsSensitivenessAnomalyThreshold struct{}

func (TsEntryPathSelectorStateModelsSensitivenessAnomalyThreshold) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Models().Sensitiveness().AnomalyThreshold().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateModelsSensitivenessAnomalyThreshold) WithValue(value float64) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateThresholds struct{}

func (TsEntryPathSelectorStateThresholds) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholds) WithValue(value []*TsEntry_State_AdaptiveThresholdInfo) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

func (s TsEntryPathSelectorStateThresholds) WithArrayOfValues(values [][]*TsEntry_State_AdaptiveThresholdInfo) *TsEntry_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldSubPathArrayOfValues)
}

func (s TsEntryPathSelectorStateThresholds) WithItemValue(value *TsEntry_State_AdaptiveThresholdInfo) *TsEntry_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntry_FieldSubPathArrayItemValue)
}

func (TsEntryPathSelectorStateThresholds) QueryName() TsEntryPathSelectorStateThresholdsQueryName {
	return TsEntryPathSelectorStateThresholdsQueryName{}
}

func (TsEntryPathSelectorStateThresholds) Lower() TsEntryPathSelectorStateThresholdsLower {
	return TsEntryPathSelectorStateThresholdsLower{}
}

func (TsEntryPathSelectorStateThresholds) Upper() TsEntryPathSelectorStateThresholdsUpper {
	return TsEntryPathSelectorStateThresholdsUpper{}
}

func (TsEntryPathSelectorStateThresholds) NextCheck() TsEntryPathSelectorStateThresholdsNextCheck {
	return TsEntryPathSelectorStateThresholdsNextCheck{}
}

type TsEntryPathSelectorStateThresholdsQueryName struct{}

func (TsEntryPathSelectorStateThresholdsQueryName) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().QueryName().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsQueryName) WithValue(value string) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateThresholdsLower struct{}

func (TsEntryPathSelectorStateThresholdsLower) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().Lower().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsLower) WithValue(value *rcommon.AlertingThreshold) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

func (TsEntryPathSelectorStateThresholdsLower) Value() TsEntryPathSelectorStateThresholdsLowerValue {
	return TsEntryPathSelectorStateThresholdsLowerValue{}
}

func (TsEntryPathSelectorStateThresholdsLower) IsInclusive() TsEntryPathSelectorStateThresholdsLowerIsInclusive {
	return TsEntryPathSelectorStateThresholdsLowerIsInclusive{}
}

type TsEntryPathSelectorStateThresholdsLowerValue struct{}

func (TsEntryPathSelectorStateThresholdsLowerValue) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().Lower().Value().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsLowerValue) WithValue(value float64) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateThresholdsLowerIsInclusive struct{}

func (TsEntryPathSelectorStateThresholdsLowerIsInclusive) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().Lower().IsInclusive().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsLowerIsInclusive) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateThresholdsUpper struct{}

func (TsEntryPathSelectorStateThresholdsUpper) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().Upper().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsUpper) WithValue(value *rcommon.AlertingThreshold) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

func (TsEntryPathSelectorStateThresholdsUpper) Value() TsEntryPathSelectorStateThresholdsUpperValue {
	return TsEntryPathSelectorStateThresholdsUpperValue{}
}

func (TsEntryPathSelectorStateThresholdsUpper) IsInclusive() TsEntryPathSelectorStateThresholdsUpperIsInclusive {
	return TsEntryPathSelectorStateThresholdsUpperIsInclusive{}
}

type TsEntryPathSelectorStateThresholdsUpperValue struct{}

func (TsEntryPathSelectorStateThresholdsUpperValue) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().Upper().Value().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsUpperValue) WithValue(value float64) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateThresholdsUpperIsInclusive struct{}

func (TsEntryPathSelectorStateThresholdsUpperIsInclusive) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().Upper().IsInclusive().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsUpperIsInclusive) WithValue(value bool) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorStateThresholdsNextCheck struct{}

func (TsEntryPathSelectorStateThresholdsNextCheck) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorState,
		subPath:  NewTsEntryStateFieldPathBuilder().Thresholds().NextCheck().FieldPath(),
	}
}

func (s TsEntryPathSelectorStateThresholdsNextCheck) WithValue(value *timestamppb.Timestamp) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInternal struct{}

func (TsEntryPathSelectorInternal) FieldPath() *TsEntry_FieldTerminalPath {
	return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorInternal}
}

func (s TsEntryPathSelectorInternal) WithValue(value *TsEntry_Internal) *TsEntry_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldTerminalPathValue)
}

func (s TsEntryPathSelectorInternal) WithArrayOfValues(values []*TsEntry_Internal) *TsEntry_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldTerminalPathArrayOfValues)
}

func (TsEntryPathSelectorInternal) WithSubPath(subPath TsEntryInternal_FieldPath) *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorInternal, subPath: subPath}
}

func (s TsEntryPathSelectorInternal) WithSubValue(subPathValue TsEntryInternal_FieldPathValue) *TsEntry_FieldSubPathValue {
	return &TsEntry_FieldSubPathValue{TsEntry_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntryPathSelectorInternal) WithSubArrayOfValues(subPathArrayOfValues TsEntryInternal_FieldPathArrayOfValues) *TsEntry_FieldSubPathArrayOfValues {
	return &TsEntry_FieldSubPathArrayOfValues{TsEntry_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntryPathSelectorInternal) WithSubArrayItemValue(subPathArrayItemValue TsEntryInternal_FieldPathArrayItemValue) *TsEntry_FieldSubPathArrayItemValue {
	return &TsEntry_FieldSubPathArrayItemValue{TsEntry_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntryPathSelectorInternal) AlertingLocation() TsEntryPathSelectorInternalAlertingLocation {
	return TsEntryPathSelectorInternalAlertingLocation{}
}

func (TsEntryPathSelectorInternal) SpecGeneration() TsEntryPathSelectorInternalSpecGeneration {
	return TsEntryPathSelectorInternalSpecGeneration{}
}

type TsEntryPathSelectorInternalAlertingLocation struct{}

func (TsEntryPathSelectorInternalAlertingLocation) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInternal,
		subPath:  NewTsEntryInternalFieldPathBuilder().AlertingLocation().FieldPath(),
	}
}

func (s TsEntryPathSelectorInternalAlertingLocation) WithValue(value rcommon.PolicySpec_ProcessingLocation) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

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

type TsEntryPathSelectorInternalSpecGeneration struct{}

func (TsEntryPathSelectorInternalSpecGeneration) FieldPath() *TsEntry_FieldSubPath {
	return &TsEntry_FieldSubPath{
		selector: TsEntry_FieldPathSelectorInternal,
		subPath:  NewTsEntryInternalFieldPathBuilder().SpecGeneration().FieldPath(),
	}
}

func (s TsEntryPathSelectorInternalSpecGeneration) WithValue(value int32) *TsEntry_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntry_FieldSubPathValue)
}

func (s TsEntryPathSelectorInternalSpecGeneration) WithArrayOfValues(values []int32) *TsEntry_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntry_FieldSubPathArrayOfValues)
}

type TsEntryInfoFieldPathBuilder struct{}

func NewTsEntryInfoFieldPathBuilder() TsEntryInfoFieldPathBuilder {
	return TsEntryInfoFieldPathBuilder{}
}
func (TsEntryInfoFieldPathBuilder) AlertingResource() TsEntry_InfoPathSelectorAlertingResource {
	return TsEntry_InfoPathSelectorAlertingResource{}
}
func (TsEntryInfoFieldPathBuilder) GroupByKey() TsEntry_InfoPathSelectorGroupByKey {
	return TsEntry_InfoPathSelectorGroupByKey{}
}
func (TsEntryInfoFieldPathBuilder) CommonMetricLabels() TsEntry_InfoPathSelectorCommonMetricLabels {
	return TsEntry_InfoPathSelectorCommonMetricLabels{}
}
func (TsEntryInfoFieldPathBuilder) CommonResourceLabels() TsEntry_InfoPathSelectorCommonResourceLabels {
	return TsEntry_InfoPathSelectorCommonResourceLabels{}
}

type TsEntry_InfoPathSelectorAlertingResource struct{}

func (TsEntry_InfoPathSelectorAlertingResource) FieldPath() *TsEntryInfo_FieldTerminalPath {
	return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorAlertingResource}
}

func (s TsEntry_InfoPathSelectorAlertingResource) WithValue(value *meta.OwnerReference) *TsEntryInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldTerminalPathValue)
}

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

func (TsEntry_InfoPathSelectorAlertingResource) WithSubPath(subPath meta.OwnerReference_FieldPath) *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{selector: TsEntryInfo_FieldPathSelectorAlertingResource, subPath: subPath}
}

func (s TsEntry_InfoPathSelectorAlertingResource) WithSubValue(subPathValue meta.OwnerReference_FieldPathValue) *TsEntryInfo_FieldSubPathValue {
	return &TsEntryInfo_FieldSubPathValue{TsEntryInfo_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_InfoPathSelectorAlertingResource) WithSubArrayOfValues(subPathArrayOfValues meta.OwnerReference_FieldPathArrayOfValues) *TsEntryInfo_FieldSubPathArrayOfValues {
	return &TsEntryInfo_FieldSubPathArrayOfValues{TsEntryInfo_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_InfoPathSelectorAlertingResource) WithSubArrayItemValue(subPathArrayItemValue meta.OwnerReference_FieldPathArrayItemValue) *TsEntryInfo_FieldSubPathArrayItemValue {
	return &TsEntryInfo_FieldSubPathArrayItemValue{TsEntryInfo_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_InfoPathSelectorAlertingResource) Kind() TsEntry_InfoPathSelectorAlertingResourceKind {
	return TsEntry_InfoPathSelectorAlertingResourceKind{}
}

func (TsEntry_InfoPathSelectorAlertingResource) Version() TsEntry_InfoPathSelectorAlertingResourceVersion {
	return TsEntry_InfoPathSelectorAlertingResourceVersion{}
}

func (TsEntry_InfoPathSelectorAlertingResource) Name() TsEntry_InfoPathSelectorAlertingResourceName {
	return TsEntry_InfoPathSelectorAlertingResourceName{}
}

func (TsEntry_InfoPathSelectorAlertingResource) Region() TsEntry_InfoPathSelectorAlertingResourceRegion {
	return TsEntry_InfoPathSelectorAlertingResourceRegion{}
}

func (TsEntry_InfoPathSelectorAlertingResource) Controller() TsEntry_InfoPathSelectorAlertingResourceController {
	return TsEntry_InfoPathSelectorAlertingResourceController{}
}

func (TsEntry_InfoPathSelectorAlertingResource) RequiresOwnerReference() TsEntry_InfoPathSelectorAlertingResourceRequiresOwnerReference {
	return TsEntry_InfoPathSelectorAlertingResourceRequiresOwnerReference{}
}

func (TsEntry_InfoPathSelectorAlertingResource) UnsetOnDelete() TsEntry_InfoPathSelectorAlertingResourceUnsetOnDelete {
	return TsEntry_InfoPathSelectorAlertingResourceUnsetOnDelete{}
}

type TsEntry_InfoPathSelectorAlertingResourceKind struct{}

func (TsEntry_InfoPathSelectorAlertingResourceKind) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Kind().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceKind) WithValue(value string) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorAlertingResourceVersion struct{}

func (TsEntry_InfoPathSelectorAlertingResourceVersion) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Version().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceVersion) WithValue(value string) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorAlertingResourceName struct{}

func (TsEntry_InfoPathSelectorAlertingResourceName) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Name().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceName) WithValue(value string) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorAlertingResourceRegion struct{}

func (TsEntry_InfoPathSelectorAlertingResourceRegion) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Region().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceRegion) WithValue(value string) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorAlertingResourceController struct{}

func (TsEntry_InfoPathSelectorAlertingResourceController) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().Controller().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceController) WithValue(value bool) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorAlertingResourceRequiresOwnerReference struct{}

func (TsEntry_InfoPathSelectorAlertingResourceRequiresOwnerReference) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().RequiresOwnerReference().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceRequiresOwnerReference) WithValue(value bool) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorAlertingResourceUnsetOnDelete struct{}

func (TsEntry_InfoPathSelectorAlertingResourceUnsetOnDelete) FieldPath() *TsEntryInfo_FieldSubPath {
	return &TsEntryInfo_FieldSubPath{
		selector: TsEntryInfo_FieldPathSelectorAlertingResource,
		subPath:  meta.NewOwnerReferenceFieldPathBuilder().UnsetOnDelete().FieldPath(),
	}
}

func (s TsEntry_InfoPathSelectorAlertingResourceUnsetOnDelete) WithValue(value bool) *TsEntryInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldSubPathValue)
}

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

type TsEntry_InfoPathSelectorGroupByKey struct{}

func (TsEntry_InfoPathSelectorGroupByKey) FieldPath() *TsEntryInfo_FieldTerminalPath {
	return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorGroupByKey}
}

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

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

type TsEntry_InfoPathSelectorCommonMetricLabels struct{}

func (TsEntry_InfoPathSelectorCommonMetricLabels) FieldPath() *TsEntryInfo_FieldTerminalPath {
	return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorCommonMetricLabels}
}

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

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

func (TsEntry_InfoPathSelectorCommonMetricLabels) WithKey(key string) TsEntry_InfoMapPathSelectorCommonMetricLabels {
	return TsEntry_InfoMapPathSelectorCommonMetricLabels{key: key}
}

type TsEntry_InfoMapPathSelectorCommonMetricLabels struct {
	key string
}

func (s TsEntry_InfoMapPathSelectorCommonMetricLabels) FieldPath() *TsEntryInfo_FieldPathMap {
	return &TsEntryInfo_FieldPathMap{selector: TsEntryInfo_FieldPathSelectorCommonMetricLabels, key: s.key}
}

func (s TsEntry_InfoMapPathSelectorCommonMetricLabels) WithValue(value string) *TsEntryInfo_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldPathMapValue)
}

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

type TsEntry_InfoPathSelectorCommonResourceLabels struct{}

func (TsEntry_InfoPathSelectorCommonResourceLabels) FieldPath() *TsEntryInfo_FieldTerminalPath {
	return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorCommonResourceLabels}
}

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

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

func (TsEntry_InfoPathSelectorCommonResourceLabels) WithKey(key string) TsEntry_InfoMapPathSelectorCommonResourceLabels {
	return TsEntry_InfoMapPathSelectorCommonResourceLabels{key: key}
}

type TsEntry_InfoMapPathSelectorCommonResourceLabels struct {
	key string
}

func (s TsEntry_InfoMapPathSelectorCommonResourceLabels) FieldPath() *TsEntryInfo_FieldPathMap {
	return &TsEntryInfo_FieldPathMap{selector: TsEntryInfo_FieldPathSelectorCommonResourceLabels, key: s.key}
}

func (s TsEntry_InfoMapPathSelectorCommonResourceLabels) WithValue(value string) *TsEntryInfo_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInfo_FieldPathMapValue)
}

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

type TsEntryStateFieldPathBuilder struct{}

func NewTsEntryStateFieldPathBuilder() TsEntryStateFieldPathBuilder {
	return TsEntryStateFieldPathBuilder{}
}
func (TsEntryStateFieldPathBuilder) Models() TsEntry_StatePathSelectorModels {
	return TsEntry_StatePathSelectorModels{}
}
func (TsEntryStateFieldPathBuilder) Thresholds() TsEntry_StatePathSelectorThresholds {
	return TsEntry_StatePathSelectorThresholds{}
}

type TsEntry_StatePathSelectorModels struct{}

func (TsEntry_StatePathSelectorModels) FieldPath() *TsEntryState_FieldTerminalPath {
	return &TsEntryState_FieldTerminalPath{selector: TsEntryState_FieldPathSelectorModels}
}

func (s TsEntry_StatePathSelectorModels) WithValue(value []*TsEntry_State_AnomalyModelData) *TsEntryState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldTerminalPathValue)
}

func (s TsEntry_StatePathSelectorModels) WithArrayOfValues(values [][]*TsEntry_State_AnomalyModelData) *TsEntryState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryState_FieldTerminalPathArrayOfValues)
}

func (s TsEntry_StatePathSelectorModels) WithItemValue(value *TsEntry_State_AnomalyModelData) *TsEntryState_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryState_FieldTerminalPathArrayItemValue)
}
func (TsEntry_StatePathSelectorModels) WithSubPath(subPath TsEntryStateAnomalyModelData_FieldPath) *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{selector: TsEntryState_FieldPathSelectorModels, subPath: subPath}
}

func (s TsEntry_StatePathSelectorModels) WithSubValue(subPathValue TsEntryStateAnomalyModelData_FieldPathValue) *TsEntryState_FieldSubPathValue {
	return &TsEntryState_FieldSubPathValue{TsEntryState_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_StatePathSelectorModels) WithSubArrayOfValues(subPathArrayOfValues TsEntryStateAnomalyModelData_FieldPathArrayOfValues) *TsEntryState_FieldSubPathArrayOfValues {
	return &TsEntryState_FieldSubPathArrayOfValues{TsEntryState_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_StatePathSelectorModels) WithSubArrayItemValue(subPathArrayItemValue TsEntryStateAnomalyModelData_FieldPathArrayItemValue) *TsEntryState_FieldSubPathArrayItemValue {
	return &TsEntryState_FieldSubPathArrayItemValue{TsEntryState_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_StatePathSelectorModels) AnalysisWindow() TsEntry_StatePathSelectorModelsAnalysisWindow {
	return TsEntry_StatePathSelectorModelsAnalysisWindow{}
}

func (TsEntry_StatePathSelectorModels) ModelData() TsEntry_StatePathSelectorModelsModelData {
	return TsEntry_StatePathSelectorModelsModelData{}
}

func (TsEntry_StatePathSelectorModels) TrainingMeanErr() TsEntry_StatePathSelectorModelsTrainingMeanErr {
	return TsEntry_StatePathSelectorModelsTrainingMeanErr{}
}

func (TsEntry_StatePathSelectorModels) TrainingMaxErr() TsEntry_StatePathSelectorModelsTrainingMaxErr {
	return TsEntry_StatePathSelectorModelsTrainingMaxErr{}
}

func (TsEntry_StatePathSelectorModels) TrainedInEpochs() TsEntry_StatePathSelectorModelsTrainedInEpochs {
	return TsEntry_StatePathSelectorModelsTrainedInEpochs{}
}

func (TsEntry_StatePathSelectorModels) TrainedIn() TsEntry_StatePathSelectorModelsTrainedIn {
	return TsEntry_StatePathSelectorModelsTrainedIn{}
}

func (TsEntry_StatePathSelectorModels) TrainAfter() TsEntry_StatePathSelectorModelsTrainAfter {
	return TsEntry_StatePathSelectorModelsTrainAfter{}
}

func (TsEntry_StatePathSelectorModels) TrainingPeriod() TsEntry_StatePathSelectorModelsTrainingPeriod {
	return TsEntry_StatePathSelectorModelsTrainingPeriod{}
}

func (TsEntry_StatePathSelectorModels) Sensitiveness() TsEntry_StatePathSelectorModelsSensitiveness {
	return TsEntry_StatePathSelectorModelsSensitiveness{}
}

type TsEntry_StatePathSelectorModelsAnalysisWindow struct{}

func (TsEntry_StatePathSelectorModelsAnalysisWindow) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().AnalysisWindow().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsAnalysisWindow) WithValue(value *durationpb.Duration) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorModelsModelData struct{}

func (TsEntry_StatePathSelectorModelsModelData) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().ModelData().FieldPath(),
	}
}

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

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

type TsEntry_StatePathSelectorModelsTrainingMeanErr struct{}

func (TsEntry_StatePathSelectorModelsTrainingMeanErr) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainingMeanErr().FieldPath(),
	}
}

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

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

func (s TsEntry_StatePathSelectorModelsTrainingMeanErr) WithItemValue(value float64) *TsEntryState_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryState_FieldSubPathArrayItemValue)
}

type TsEntry_StatePathSelectorModelsTrainingMaxErr struct{}

func (TsEntry_StatePathSelectorModelsTrainingMaxErr) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainingMaxErr().FieldPath(),
	}
}

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

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

func (s TsEntry_StatePathSelectorModelsTrainingMaxErr) WithItemValue(value float64) *TsEntryState_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryState_FieldSubPathArrayItemValue)
}

type TsEntry_StatePathSelectorModelsTrainedInEpochs struct{}

func (TsEntry_StatePathSelectorModelsTrainedInEpochs) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainedInEpochs().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsTrainedInEpochs) WithValue(value int32) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

func (s TsEntry_StatePathSelectorModelsTrainedInEpochs) WithArrayOfValues(values []int32) *TsEntryState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryState_FieldSubPathArrayOfValues)
}

type TsEntry_StatePathSelectorModelsTrainedIn struct{}

func (TsEntry_StatePathSelectorModelsTrainedIn) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainedIn().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsTrainedIn) WithValue(value *durationpb.Duration) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorModelsTrainAfter struct{}

func (TsEntry_StatePathSelectorModelsTrainAfter) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainAfter().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsTrainAfter) WithValue(value *timestamppb.Timestamp) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorModelsTrainingPeriod struct{}

func (TsEntry_StatePathSelectorModelsTrainingPeriod) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainingPeriod().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsTrainingPeriod) WithValue(value *monitoring_common.TimeInterval) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

func (s TsEntry_StatePathSelectorModelsTrainingPeriod) WithArrayOfValues(values []*monitoring_common.TimeInterval) *TsEntryState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryState_FieldSubPathArrayOfValues)
}

func (TsEntry_StatePathSelectorModelsTrainingPeriod) EndTime() TsEntry_StatePathSelectorModelsTrainingPeriodEndTime {
	return TsEntry_StatePathSelectorModelsTrainingPeriodEndTime{}
}

func (TsEntry_StatePathSelectorModelsTrainingPeriod) StartTime() TsEntry_StatePathSelectorModelsTrainingPeriodStartTime {
	return TsEntry_StatePathSelectorModelsTrainingPeriodStartTime{}
}

type TsEntry_StatePathSelectorModelsTrainingPeriodEndTime struct{}

func (TsEntry_StatePathSelectorModelsTrainingPeriodEndTime) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainingPeriod().EndTime().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsTrainingPeriodEndTime) WithValue(value *timestamppb.Timestamp) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorModelsTrainingPeriodStartTime struct{}

func (TsEntry_StatePathSelectorModelsTrainingPeriodStartTime) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().TrainingPeriod().StartTime().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsTrainingPeriodStartTime) WithValue(value *timestamppb.Timestamp) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorModelsSensitiveness struct{}

func (TsEntry_StatePathSelectorModelsSensitiveness) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().Sensitiveness().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsSensitiveness) WithValue(value []*TsEntry_State_AnomalyModelSensitiveness) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

func (s TsEntry_StatePathSelectorModelsSensitiveness) WithArrayOfValues(values [][]*TsEntry_State_AnomalyModelSensitiveness) *TsEntryState_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryState_FieldSubPathArrayOfValues)
}

func (s TsEntry_StatePathSelectorModelsSensitiveness) WithItemValue(value *TsEntry_State_AnomalyModelSensitiveness) *TsEntryState_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryState_FieldSubPathArrayItemValue)
}

func (TsEntry_StatePathSelectorModelsSensitiveness) QueryName() TsEntry_StatePathSelectorModelsSensitivenessQueryName {
	return TsEntry_StatePathSelectorModelsSensitivenessQueryName{}
}

func (TsEntry_StatePathSelectorModelsSensitiveness) AnomalyThreshold() TsEntry_StatePathSelectorModelsSensitivenessAnomalyThreshold {
	return TsEntry_StatePathSelectorModelsSensitivenessAnomalyThreshold{}
}

type TsEntry_StatePathSelectorModelsSensitivenessQueryName struct{}

func (TsEntry_StatePathSelectorModelsSensitivenessQueryName) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().Sensitiveness().QueryName().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsSensitivenessQueryName) WithValue(value string) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorModelsSensitivenessAnomalyThreshold struct{}

func (TsEntry_StatePathSelectorModelsSensitivenessAnomalyThreshold) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorModels,
		subPath:  NewTsEntryStateAnomalyModelDataFieldPathBuilder().Sensitiveness().AnomalyThreshold().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorModelsSensitivenessAnomalyThreshold) WithValue(value float64) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorThresholds struct{}

func (TsEntry_StatePathSelectorThresholds) FieldPath() *TsEntryState_FieldTerminalPath {
	return &TsEntryState_FieldTerminalPath{selector: TsEntryState_FieldPathSelectorThresholds}
}

func (s TsEntry_StatePathSelectorThresholds) WithValue(value []*TsEntry_State_AdaptiveThresholdInfo) *TsEntryState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldTerminalPathValue)
}

func (s TsEntry_StatePathSelectorThresholds) WithArrayOfValues(values [][]*TsEntry_State_AdaptiveThresholdInfo) *TsEntryState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryState_FieldTerminalPathArrayOfValues)
}

func (s TsEntry_StatePathSelectorThresholds) WithItemValue(value *TsEntry_State_AdaptiveThresholdInfo) *TsEntryState_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryState_FieldTerminalPathArrayItemValue)
}
func (TsEntry_StatePathSelectorThresholds) WithSubPath(subPath TsEntryStateAdaptiveThresholdInfo_FieldPath) *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{selector: TsEntryState_FieldPathSelectorThresholds, subPath: subPath}
}

func (s TsEntry_StatePathSelectorThresholds) WithSubValue(subPathValue TsEntryStateAdaptiveThresholdInfo_FieldPathValue) *TsEntryState_FieldSubPathValue {
	return &TsEntryState_FieldSubPathValue{TsEntryState_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_StatePathSelectorThresholds) WithSubArrayOfValues(subPathArrayOfValues TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues) *TsEntryState_FieldSubPathArrayOfValues {
	return &TsEntryState_FieldSubPathArrayOfValues{TsEntryState_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_StatePathSelectorThresholds) WithSubArrayItemValue(subPathArrayItemValue TsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue) *TsEntryState_FieldSubPathArrayItemValue {
	return &TsEntryState_FieldSubPathArrayItemValue{TsEntryState_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_StatePathSelectorThresholds) QueryName() TsEntry_StatePathSelectorThresholdsQueryName {
	return TsEntry_StatePathSelectorThresholdsQueryName{}
}

func (TsEntry_StatePathSelectorThresholds) Lower() TsEntry_StatePathSelectorThresholdsLower {
	return TsEntry_StatePathSelectorThresholdsLower{}
}

func (TsEntry_StatePathSelectorThresholds) Upper() TsEntry_StatePathSelectorThresholdsUpper {
	return TsEntry_StatePathSelectorThresholdsUpper{}
}

func (TsEntry_StatePathSelectorThresholds) NextCheck() TsEntry_StatePathSelectorThresholdsNextCheck {
	return TsEntry_StatePathSelectorThresholdsNextCheck{}
}

type TsEntry_StatePathSelectorThresholdsQueryName struct{}

func (TsEntry_StatePathSelectorThresholdsQueryName) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().QueryName().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsQueryName) WithValue(value string) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorThresholdsLower struct{}

func (TsEntry_StatePathSelectorThresholdsLower) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().Lower().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsLower) WithValue(value *rcommon.AlertingThreshold) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

func (TsEntry_StatePathSelectorThresholdsLower) Value() TsEntry_StatePathSelectorThresholdsLowerValue {
	return TsEntry_StatePathSelectorThresholdsLowerValue{}
}

func (TsEntry_StatePathSelectorThresholdsLower) IsInclusive() TsEntry_StatePathSelectorThresholdsLowerIsInclusive {
	return TsEntry_StatePathSelectorThresholdsLowerIsInclusive{}
}

type TsEntry_StatePathSelectorThresholdsLowerValue struct{}

func (TsEntry_StatePathSelectorThresholdsLowerValue) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().Lower().Value().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsLowerValue) WithValue(value float64) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorThresholdsLowerIsInclusive struct{}

func (TsEntry_StatePathSelectorThresholdsLowerIsInclusive) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().Lower().IsInclusive().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsLowerIsInclusive) WithValue(value bool) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorThresholdsUpper struct{}

func (TsEntry_StatePathSelectorThresholdsUpper) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().Upper().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsUpper) WithValue(value *rcommon.AlertingThreshold) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

func (TsEntry_StatePathSelectorThresholdsUpper) Value() TsEntry_StatePathSelectorThresholdsUpperValue {
	return TsEntry_StatePathSelectorThresholdsUpperValue{}
}

func (TsEntry_StatePathSelectorThresholdsUpper) IsInclusive() TsEntry_StatePathSelectorThresholdsUpperIsInclusive {
	return TsEntry_StatePathSelectorThresholdsUpperIsInclusive{}
}

type TsEntry_StatePathSelectorThresholdsUpperValue struct{}

func (TsEntry_StatePathSelectorThresholdsUpperValue) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().Upper().Value().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsUpperValue) WithValue(value float64) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorThresholdsUpperIsInclusive struct{}

func (TsEntry_StatePathSelectorThresholdsUpperIsInclusive) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().Upper().IsInclusive().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsUpperIsInclusive) WithValue(value bool) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntry_StatePathSelectorThresholdsNextCheck struct{}

func (TsEntry_StatePathSelectorThresholdsNextCheck) FieldPath() *TsEntryState_FieldSubPath {
	return &TsEntryState_FieldSubPath{
		selector: TsEntryState_FieldPathSelectorThresholds,
		subPath:  NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder().NextCheck().FieldPath(),
	}
}

func (s TsEntry_StatePathSelectorThresholdsNextCheck) WithValue(value *timestamppb.Timestamp) *TsEntryState_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryState_FieldSubPathValue)
}

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

type TsEntryInternalFieldPathBuilder struct{}

func NewTsEntryInternalFieldPathBuilder() TsEntryInternalFieldPathBuilder {
	return TsEntryInternalFieldPathBuilder{}
}
func (TsEntryInternalFieldPathBuilder) AlertingLocation() TsEntry_InternalPathSelectorAlertingLocation {
	return TsEntry_InternalPathSelectorAlertingLocation{}
}
func (TsEntryInternalFieldPathBuilder) SpecGeneration() TsEntry_InternalPathSelectorSpecGeneration {
	return TsEntry_InternalPathSelectorSpecGeneration{}
}

type TsEntry_InternalPathSelectorAlertingLocation struct{}

func (TsEntry_InternalPathSelectorAlertingLocation) FieldPath() *TsEntryInternal_FieldTerminalPath {
	return &TsEntryInternal_FieldTerminalPath{selector: TsEntryInternal_FieldPathSelectorAlertingLocation}
}

func (s TsEntry_InternalPathSelectorAlertingLocation) WithValue(value rcommon.PolicySpec_ProcessingLocation) *TsEntryInternal_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInternal_FieldTerminalPathValue)
}

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

type TsEntry_InternalPathSelectorSpecGeneration struct{}

func (TsEntry_InternalPathSelectorSpecGeneration) FieldPath() *TsEntryInternal_FieldTerminalPath {
	return &TsEntryInternal_FieldTerminalPath{selector: TsEntryInternal_FieldPathSelectorSpecGeneration}
}

func (s TsEntry_InternalPathSelectorSpecGeneration) WithValue(value int32) *TsEntryInternal_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryInternal_FieldTerminalPathValue)
}

func (s TsEntry_InternalPathSelectorSpecGeneration) WithArrayOfValues(values []int32) *TsEntryInternal_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryInternal_FieldTerminalPathArrayOfValues)
}

type TsEntryStateAnomalyModelDataFieldPathBuilder struct{}

func NewTsEntryStateAnomalyModelDataFieldPathBuilder() TsEntryStateAnomalyModelDataFieldPathBuilder {
	return TsEntryStateAnomalyModelDataFieldPathBuilder{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) AnalysisWindow() TsEntry_State_AnomalyModelDataPathSelectorAnalysisWindow {
	return TsEntry_State_AnomalyModelDataPathSelectorAnalysisWindow{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) ModelData() TsEntry_State_AnomalyModelDataPathSelectorModelData {
	return TsEntry_State_AnomalyModelDataPathSelectorModelData{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) TrainingMeanErr() TsEntry_State_AnomalyModelDataPathSelectorTrainingMeanErr {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainingMeanErr{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) TrainingMaxErr() TsEntry_State_AnomalyModelDataPathSelectorTrainingMaxErr {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainingMaxErr{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) TrainedInEpochs() TsEntry_State_AnomalyModelDataPathSelectorTrainedInEpochs {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainedInEpochs{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) TrainedIn() TsEntry_State_AnomalyModelDataPathSelectorTrainedIn {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainedIn{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) TrainAfter() TsEntry_State_AnomalyModelDataPathSelectorTrainAfter {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainAfter{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) TrainingPeriod() TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod{}
}
func (TsEntryStateAnomalyModelDataFieldPathBuilder) Sensitiveness() TsEntry_State_AnomalyModelDataPathSelectorSensitiveness {
	return TsEntry_State_AnomalyModelDataPathSelectorSensitiveness{}
}

type TsEntry_State_AnomalyModelDataPathSelectorAnalysisWindow struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorAnalysisWindow) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorAnalysisWindow) WithValue(value *durationpb.Duration) *TsEntryStateAnomalyModelData_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathValue)
}

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

type TsEntry_State_AnomalyModelDataPathSelectorModelData struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorModelData) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorModelData}
}

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

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

type TsEntry_State_AnomalyModelDataPathSelectorTrainingMeanErr struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingMeanErr) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr}
}

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

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

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingMeanErr) WithItemValue(value float64) *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue)
}

type TsEntry_State_AnomalyModelDataPathSelectorTrainingMaxErr struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingMaxErr) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr}
}

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

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

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingMaxErr) WithItemValue(value float64) *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue)
}

type TsEntry_State_AnomalyModelDataPathSelectorTrainedInEpochs struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainedInEpochs) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainedInEpochs) WithValue(value int32) *TsEntryStateAnomalyModelData_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathValue)
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainedInEpochs) WithArrayOfValues(values []int32) *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues)
}

type TsEntry_State_AnomalyModelDataPathSelectorTrainedIn struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainedIn) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainedIn) WithValue(value *durationpb.Duration) *TsEntryStateAnomalyModelData_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathValue)
}

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

type TsEntry_State_AnomalyModelDataPathSelectorTrainAfter struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainAfter) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainAfter) WithValue(value *timestamppb.Timestamp) *TsEntryStateAnomalyModelData_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathValue)
}

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

type TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) WithValue(value *monitoring_common.TimeInterval) *TsEntryStateAnomalyModelData_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathValue)
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) WithArrayOfValues(values []*monitoring_common.TimeInterval) *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues)
}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) WithSubPath(subPath monitoring_common.TimeInterval_FieldPath) *TsEntryStateAnomalyModelData_FieldSubPath {
	return &TsEntryStateAnomalyModelData_FieldSubPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod, subPath: subPath}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) WithSubValue(subPathValue monitoring_common.TimeInterval_FieldPathValue) *TsEntryStateAnomalyModelData_FieldSubPathValue {
	return &TsEntryStateAnomalyModelData_FieldSubPathValue{TsEntryStateAnomalyModelData_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) WithSubArrayOfValues(subPathArrayOfValues monitoring_common.TimeInterval_FieldPathArrayOfValues) *TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues {
	return &TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues{TsEntryStateAnomalyModelData_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) WithSubArrayItemValue(subPathArrayItemValue monitoring_common.TimeInterval_FieldPathArrayItemValue) *TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue {
	return &TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue{TsEntryStateAnomalyModelData_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) EndTime() TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodEndTime {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodEndTime{}
}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriod) StartTime() TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodStartTime {
	return TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodStartTime{}
}

type TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodEndTime struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodEndTime) FieldPath() *TsEntryStateAnomalyModelData_FieldSubPath {
	return &TsEntryStateAnomalyModelData_FieldSubPath{
		selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod,
		subPath:  monitoring_common.NewTimeIntervalFieldPathBuilder().EndTime().FieldPath(),
	}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodEndTime) WithValue(value *timestamppb.Timestamp) *TsEntryStateAnomalyModelData_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldSubPathValue)
}

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

type TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodStartTime struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodStartTime) FieldPath() *TsEntryStateAnomalyModelData_FieldSubPath {
	return &TsEntryStateAnomalyModelData_FieldSubPath{
		selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod,
		subPath:  monitoring_common.NewTimeIntervalFieldPathBuilder().StartTime().FieldPath(),
	}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorTrainingPeriodStartTime) WithValue(value *timestamppb.Timestamp) *TsEntryStateAnomalyModelData_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldSubPathValue)
}

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

type TsEntry_State_AnomalyModelDataPathSelectorSensitiveness struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) FieldPath() *TsEntryStateAnomalyModelData_FieldTerminalPath {
	return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithValue(value []*TsEntry_State_AnomalyModelSensitiveness) *TsEntryStateAnomalyModelData_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathValue)
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithArrayOfValues(values [][]*TsEntry_State_AnomalyModelSensitiveness) *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues)
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithItemValue(value *TsEntry_State_AnomalyModelSensitiveness) *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue)
}
func (TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithSubPath(subPath TsEntryStateAnomalyModelSensitiveness_FieldPath) *TsEntryStateAnomalyModelData_FieldSubPath {
	return &TsEntryStateAnomalyModelData_FieldSubPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness, subPath: subPath}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithSubValue(subPathValue TsEntryStateAnomalyModelSensitiveness_FieldPathValue) *TsEntryStateAnomalyModelData_FieldSubPathValue {
	return &TsEntryStateAnomalyModelData_FieldSubPathValue{TsEntryStateAnomalyModelData_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithSubArrayOfValues(subPathArrayOfValues TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues) *TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues {
	return &TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues{TsEntryStateAnomalyModelData_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) WithSubArrayItemValue(subPathArrayItemValue TsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue) *TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue {
	return &TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue{TsEntryStateAnomalyModelData_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) QueryName() TsEntry_State_AnomalyModelDataPathSelectorSensitivenessQueryName {
	return TsEntry_State_AnomalyModelDataPathSelectorSensitivenessQueryName{}
}

func (TsEntry_State_AnomalyModelDataPathSelectorSensitiveness) AnomalyThreshold() TsEntry_State_AnomalyModelDataPathSelectorSensitivenessAnomalyThreshold {
	return TsEntry_State_AnomalyModelDataPathSelectorSensitivenessAnomalyThreshold{}
}

type TsEntry_State_AnomalyModelDataPathSelectorSensitivenessQueryName struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorSensitivenessQueryName) FieldPath() *TsEntryStateAnomalyModelData_FieldSubPath {
	return &TsEntryStateAnomalyModelData_FieldSubPath{
		selector: TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness,
		subPath:  NewTsEntryStateAnomalyModelSensitivenessFieldPathBuilder().QueryName().FieldPath(),
	}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitivenessQueryName) WithValue(value string) *TsEntryStateAnomalyModelData_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldSubPathValue)
}

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

type TsEntry_State_AnomalyModelDataPathSelectorSensitivenessAnomalyThreshold struct{}

func (TsEntry_State_AnomalyModelDataPathSelectorSensitivenessAnomalyThreshold) FieldPath() *TsEntryStateAnomalyModelData_FieldSubPath {
	return &TsEntryStateAnomalyModelData_FieldSubPath{
		selector: TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness,
		subPath:  NewTsEntryStateAnomalyModelSensitivenessFieldPathBuilder().AnomalyThreshold().FieldPath(),
	}
}

func (s TsEntry_State_AnomalyModelDataPathSelectorSensitivenessAnomalyThreshold) WithValue(value float64) *TsEntryStateAnomalyModelData_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelData_FieldSubPathValue)
}

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

type TsEntryStateAnomalyModelSensitivenessFieldPathBuilder struct{}

func NewTsEntryStateAnomalyModelSensitivenessFieldPathBuilder() TsEntryStateAnomalyModelSensitivenessFieldPathBuilder {
	return TsEntryStateAnomalyModelSensitivenessFieldPathBuilder{}
}
func (TsEntryStateAnomalyModelSensitivenessFieldPathBuilder) QueryName() TsEntry_State_AnomalyModelSensitivenessPathSelectorQueryName {
	return TsEntry_State_AnomalyModelSensitivenessPathSelectorQueryName{}
}
func (TsEntryStateAnomalyModelSensitivenessFieldPathBuilder) AnomalyThreshold() TsEntry_State_AnomalyModelSensitivenessPathSelectorAnomalyThreshold {
	return TsEntry_State_AnomalyModelSensitivenessPathSelectorAnomalyThreshold{}
}

type TsEntry_State_AnomalyModelSensitivenessPathSelectorQueryName struct{}

func (TsEntry_State_AnomalyModelSensitivenessPathSelectorQueryName) FieldPath() *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath {
	return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath{selector: TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName}
}

func (s TsEntry_State_AnomalyModelSensitivenessPathSelectorQueryName) WithValue(value string) *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue)
}

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

type TsEntry_State_AnomalyModelSensitivenessPathSelectorAnomalyThreshold struct{}

func (TsEntry_State_AnomalyModelSensitivenessPathSelectorAnomalyThreshold) FieldPath() *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath {
	return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath{selector: TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold}
}

func (s TsEntry_State_AnomalyModelSensitivenessPathSelectorAnomalyThreshold) WithValue(value float64) *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue)
}

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

type TsEntryStateAdaptiveThresholdInfoFieldPathBuilder struct{}

func NewTsEntryStateAdaptiveThresholdInfoFieldPathBuilder() TsEntryStateAdaptiveThresholdInfoFieldPathBuilder {
	return TsEntryStateAdaptiveThresholdInfoFieldPathBuilder{}
}
func (TsEntryStateAdaptiveThresholdInfoFieldPathBuilder) QueryName() TsEntry_State_AdaptiveThresholdInfoPathSelectorQueryName {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorQueryName{}
}
func (TsEntryStateAdaptiveThresholdInfoFieldPathBuilder) Lower() TsEntry_State_AdaptiveThresholdInfoPathSelectorLower {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorLower{}
}
func (TsEntryStateAdaptiveThresholdInfoFieldPathBuilder) Upper() TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper{}
}
func (TsEntryStateAdaptiveThresholdInfoFieldPathBuilder) NextCheck() TsEntry_State_AdaptiveThresholdInfoPathSelectorNextCheck {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorNextCheck{}
}

type TsEntry_State_AdaptiveThresholdInfoPathSelectorQueryName struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorQueryName) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorQueryName) WithValue(value string) *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue)
}

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

type TsEntry_State_AdaptiveThresholdInfoPathSelectorLower struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) WithValue(value *rcommon.AlertingThreshold) *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue)
}

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

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) WithSubPath(subPath rcommon.AlertingThreshold_FieldPath) *TsEntryStateAdaptiveThresholdInfo_FieldSubPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower, subPath: subPath}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) WithSubValue(subPathValue rcommon.AlertingThreshold_FieldPathValue) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue{TsEntryStateAdaptiveThresholdInfo_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) WithSubArrayOfValues(subPathArrayOfValues rcommon.AlertingThreshold_FieldPathArrayOfValues) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) WithSubArrayItemValue(subPathArrayItemValue rcommon.AlertingThreshold_FieldPathArrayItemValue) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue{TsEntryStateAdaptiveThresholdInfo_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) Value() TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerValue {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerValue{}
}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorLower) IsInclusive() TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerIsInclusive {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerIsInclusive{}
}

type TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerValue struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerValue) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldSubPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{
		selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().Value().FieldPath(),
	}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerValue) WithValue(value float64) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue)
}

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

type TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerIsInclusive struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerIsInclusive) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldSubPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{
		selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().IsInclusive().FieldPath(),
	}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorLowerIsInclusive) WithValue(value bool) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue)
}

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

type TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) WithValue(value *rcommon.AlertingThreshold) *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue)
}

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

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) WithSubPath(subPath rcommon.AlertingThreshold_FieldPath) *TsEntryStateAdaptiveThresholdInfo_FieldSubPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper, subPath: subPath}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) WithSubValue(subPathValue rcommon.AlertingThreshold_FieldPathValue) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue{TsEntryStateAdaptiveThresholdInfo_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) WithSubArrayOfValues(subPathArrayOfValues rcommon.AlertingThreshold_FieldPathArrayOfValues) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) WithSubArrayItemValue(subPathArrayItemValue rcommon.AlertingThreshold_FieldPathArrayItemValue) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue{TsEntryStateAdaptiveThresholdInfo_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) Value() TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperValue {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperValue{}
}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorUpper) IsInclusive() TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperIsInclusive {
	return TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperIsInclusive{}
}

type TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperValue struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperValue) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldSubPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{
		selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().Value().FieldPath(),
	}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperValue) WithValue(value float64) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue)
}

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

type TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperIsInclusive struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperIsInclusive) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldSubPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{
		selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper,
		subPath:  rcommon.NewAlertingThresholdFieldPathBuilder().IsInclusive().FieldPath(),
	}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorUpperIsInclusive) WithValue(value bool) *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue)
}

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

type TsEntry_State_AdaptiveThresholdInfoPathSelectorNextCheck struct{}

func (TsEntry_State_AdaptiveThresholdInfoPathSelectorNextCheck) FieldPath() *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath {
	return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck}
}

func (s TsEntry_State_AdaptiveThresholdInfoPathSelectorNextCheck) WithValue(value *timestamppb.Timestamp) *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue)
}

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