github.com/cloudwan/edgelq-sdk@v1.15.4/applications/resources/v1alpha2/pod/pod.pb.fieldpathbuilder.go

// Code generated by protoc-gen-goten-object
// File: edgelq/applications/proto/v1alpha2/pod.proto
// DO NOT EDIT!!!

package pod

// proto imports
import (
	common "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/common"
	distribution "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/distribution"
	project "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/project"
	devices_device "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/device"
	devices_project "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/service_account"
	meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
	secrets_project "github.com/cloudwan/edgelq-sdk/secrets/resources/v1alpha2/project"
	secrets_secret "github.com/cloudwan/edgelq-sdk/secrets/resources/v1alpha2/secret"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	latlng "google.golang.org/genproto/googleapis/type/latlng"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// make sure we're using proto imports
var (
	_ = &common.PodSpec{}
	_ = &distribution.Distribution{}
	_ = &project.Project{}
	_ = &devices_device.Device{}
	_ = &devices_project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &meta_service.Service{}
	_ = &secrets_project.Project{}
	_ = &secrets_secret.Secret{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type PodFieldPathBuilder struct{}

func NewPodFieldPathBuilder() PodFieldPathBuilder {
	return PodFieldPathBuilder{}
}
func (PodFieldPathBuilder) Name() PodPathSelectorName {
	return PodPathSelectorName{}
}
func (PodFieldPathBuilder) DisplayName() PodPathSelectorDisplayName {
	return PodPathSelectorDisplayName{}
}
func (PodFieldPathBuilder) Metadata() PodPathSelectorMetadata {
	return PodPathSelectorMetadata{}
}
func (PodFieldPathBuilder) Spec() PodPathSelectorSpec {
	return PodPathSelectorSpec{}
}
func (PodFieldPathBuilder) Distribution() PodPathSelectorDistribution {
	return PodPathSelectorDistribution{}
}
func (PodFieldPathBuilder) Status() PodPathSelectorStatus {
	return PodPathSelectorStatus{}
}

type PodPathSelectorName struct{}

func (PodPathSelectorName) FieldPath() *Pod_FieldTerminalPath {
	return &Pod_FieldTerminalPath{selector: Pod_FieldPathSelectorName}
}

func (s PodPathSelectorName) WithValue(value *Name) *Pod_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldTerminalPathValue)
}

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

type PodPathSelectorDisplayName struct{}

func (PodPathSelectorDisplayName) FieldPath() *Pod_FieldTerminalPath {
	return &Pod_FieldTerminalPath{selector: Pod_FieldPathSelectorDisplayName}
}

func (s PodPathSelectorDisplayName) WithValue(value string) *Pod_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldTerminalPathValue)
}

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

type PodPathSelectorMetadata struct{}

func (PodPathSelectorMetadata) FieldPath() *Pod_FieldTerminalPath {
	return &Pod_FieldTerminalPath{selector: Pod_FieldPathSelectorMetadata}
}

func (s PodPathSelectorMetadata) WithValue(value *meta.Meta) *Pod_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldTerminalPathValue)
}

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

func (PodPathSelectorMetadata) WithSubPath(subPath meta.Meta_FieldPath) *Pod_FieldSubPath {
	return &Pod_FieldSubPath{selector: Pod_FieldPathSelectorMetadata, subPath: subPath}
}

func (s PodPathSelectorMetadata) WithSubValue(subPathValue meta.Meta_FieldPathValue) *Pod_FieldSubPathValue {
	return &Pod_FieldSubPathValue{Pod_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues meta.Meta_FieldPathArrayOfValues) *Pod_FieldSubPathArrayOfValues {
	return &Pod_FieldSubPathArrayOfValues{Pod_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue meta.Meta_FieldPathArrayItemValue) *Pod_FieldSubPathArrayItemValue {
	return &Pod_FieldSubPathArrayItemValue{Pod_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodPathSelectorMetadata) CreateTime() PodPathSelectorMetadataCreateTime {
	return PodPathSelectorMetadataCreateTime{}
}

func (PodPathSelectorMetadata) UpdateTime() PodPathSelectorMetadataUpdateTime {
	return PodPathSelectorMetadataUpdateTime{}
}

func (PodPathSelectorMetadata) DeleteTime() PodPathSelectorMetadataDeleteTime {
	return PodPathSelectorMetadataDeleteTime{}
}

func (PodPathSelectorMetadata) Uuid() PodPathSelectorMetadataUuid {
	return PodPathSelectorMetadataUuid{}
}

func (PodPathSelectorMetadata) Tags() PodPathSelectorMetadataTags {
	return PodPathSelectorMetadataTags{}
}

func (PodPathSelectorMetadata) Labels() PodPathSelectorMetadataLabels {
	return PodPathSelectorMetadataLabels{}
}

func (PodPathSelectorMetadata) Annotations() PodPathSelectorMetadataAnnotations {
	return PodPathSelectorMetadataAnnotations{}
}

func (PodPathSelectorMetadata) Generation() PodPathSelectorMetadataGeneration {
	return PodPathSelectorMetadataGeneration{}
}

func (PodPathSelectorMetadata) ResourceVersion() PodPathSelectorMetadataResourceVersion {
	return PodPathSelectorMetadataResourceVersion{}
}

func (PodPathSelectorMetadata) OwnerReferences() PodPathSelectorMetadataOwnerReferences {
	return PodPathSelectorMetadataOwnerReferences{}
}

func (PodPathSelectorMetadata) Shards() PodPathSelectorMetadataShards {
	return PodPathSelectorMetadataShards{}
}

func (PodPathSelectorMetadata) Syncing() PodPathSelectorMetadataSyncing {
	return PodPathSelectorMetadataSyncing{}
}

func (PodPathSelectorMetadata) Lifecycle() PodPathSelectorMetadataLifecycle {
	return PodPathSelectorMetadataLifecycle{}
}

func (PodPathSelectorMetadata) Services() PodPathSelectorMetadataServices {
	return PodPathSelectorMetadataServices{}
}

type PodPathSelectorMetadataCreateTime struct{}

func (PodPathSelectorMetadataCreateTime) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s PodPathSelectorMetadataCreateTime) WithValue(value *timestamppb.Timestamp) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataUpdateTime struct{}

func (PodPathSelectorMetadataUpdateTime) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s PodPathSelectorMetadataUpdateTime) WithValue(value *timestamppb.Timestamp) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataDeleteTime struct{}

func (PodPathSelectorMetadataDeleteTime) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s PodPathSelectorMetadataDeleteTime) WithValue(value *timestamppb.Timestamp) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataUuid struct{}

func (PodPathSelectorMetadataUuid) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s PodPathSelectorMetadataUuid) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataTags struct{}

func (PodPathSelectorMetadataTags) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

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

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

func (s PodPathSelectorMetadataTags) WithItemValue(value string) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

type PodPathSelectorMetadataLabels struct{}

func (PodPathSelectorMetadataLabels) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

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

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

func (PodPathSelectorMetadataLabels) WithKey(key string) PodMapPathSelectorMetadataLabels {
	return PodMapPathSelectorMetadataLabels{key: key}
}

type PodMapPathSelectorMetadataLabels struct {
	key string
}

func (s PodMapPathSelectorMetadataLabels) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s PodMapPathSelectorMetadataLabels) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataAnnotations struct{}

func (PodPathSelectorMetadataAnnotations) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

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

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

func (PodPathSelectorMetadataAnnotations) WithKey(key string) PodMapPathSelectorMetadataAnnotations {
	return PodMapPathSelectorMetadataAnnotations{key: key}
}

type PodMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s PodMapPathSelectorMetadataAnnotations) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s PodMapPathSelectorMetadataAnnotations) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataGeneration struct{}

func (PodPathSelectorMetadataGeneration) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s PodPathSelectorMetadataGeneration) WithValue(value int64) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataResourceVersion struct{}

func (PodPathSelectorMetadataResourceVersion) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s PodPathSelectorMetadataResourceVersion) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferences struct{}

func (PodPathSelectorMetadataOwnerReferences) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

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

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

func (s PodPathSelectorMetadataOwnerReferences) WithItemValue(value *meta.OwnerReference) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorMetadataOwnerReferences) Kind() PodPathSelectorMetadataOwnerReferencesKind {
	return PodPathSelectorMetadataOwnerReferencesKind{}
}

func (PodPathSelectorMetadataOwnerReferences) Version() PodPathSelectorMetadataOwnerReferencesVersion {
	return PodPathSelectorMetadataOwnerReferencesVersion{}
}

func (PodPathSelectorMetadataOwnerReferences) Name() PodPathSelectorMetadataOwnerReferencesName {
	return PodPathSelectorMetadataOwnerReferencesName{}
}

func (PodPathSelectorMetadataOwnerReferences) Region() PodPathSelectorMetadataOwnerReferencesRegion {
	return PodPathSelectorMetadataOwnerReferencesRegion{}
}

func (PodPathSelectorMetadataOwnerReferences) Controller() PodPathSelectorMetadataOwnerReferencesController {
	return PodPathSelectorMetadataOwnerReferencesController{}
}

func (PodPathSelectorMetadataOwnerReferences) RequiresOwnerReference() PodPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return PodPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

func (PodPathSelectorMetadataOwnerReferences) UnsetOnDelete() PodPathSelectorMetadataOwnerReferencesUnsetOnDelete {
	return PodPathSelectorMetadataOwnerReferencesUnsetOnDelete{}
}

type PodPathSelectorMetadataOwnerReferencesKind struct{}

func (PodPathSelectorMetadataOwnerReferencesKind) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferencesVersion struct{}

func (PodPathSelectorMetadataOwnerReferencesVersion) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferencesName struct{}

func (PodPathSelectorMetadataOwnerReferencesName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferencesRegion struct{}

func (PodPathSelectorMetadataOwnerReferencesRegion) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferencesController struct{}

func (PodPathSelectorMetadataOwnerReferencesController) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (PodPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataOwnerReferencesUnsetOnDelete struct{}

func (PodPathSelectorMetadataOwnerReferencesUnsetOnDelete) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().UnsetOnDelete().FieldPath(),
	}
}

func (s PodPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataShards struct{}

func (PodPathSelectorMetadataShards) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

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

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

func (PodPathSelectorMetadataShards) WithKey(key string) PodMapPathSelectorMetadataShards {
	return PodMapPathSelectorMetadataShards{key: key}
}

type PodMapPathSelectorMetadataShards struct {
	key string
}

func (s PodMapPathSelectorMetadataShards) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s PodMapPathSelectorMetadataShards) WithValue(value int64) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataSyncing struct{}

func (PodPathSelectorMetadataSyncing) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s PodPathSelectorMetadataSyncing) WithValue(value *meta.SyncingMeta) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

func (PodPathSelectorMetadataSyncing) OwningRegion() PodPathSelectorMetadataSyncingOwningRegion {
	return PodPathSelectorMetadataSyncingOwningRegion{}
}

func (PodPathSelectorMetadataSyncing) Regions() PodPathSelectorMetadataSyncingRegions {
	return PodPathSelectorMetadataSyncingRegions{}
}

type PodPathSelectorMetadataSyncingOwningRegion struct{}

func (PodPathSelectorMetadataSyncingOwningRegion) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s PodPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataSyncingRegions struct{}

func (PodPathSelectorMetadataSyncingRegions) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

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

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

func (s PodPathSelectorMetadataSyncingRegions) WithItemValue(value string) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

type PodPathSelectorMetadataLifecycle struct{}

func (PodPathSelectorMetadataLifecycle) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s PodPathSelectorMetadataLifecycle) WithValue(value *meta.Lifecycle) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

func (PodPathSelectorMetadataLifecycle) State() PodPathSelectorMetadataLifecycleState {
	return PodPathSelectorMetadataLifecycleState{}
}

func (PodPathSelectorMetadataLifecycle) BlockDeletion() PodPathSelectorMetadataLifecycleBlockDeletion {
	return PodPathSelectorMetadataLifecycleBlockDeletion{}
}

type PodPathSelectorMetadataLifecycleState struct{}

func (PodPathSelectorMetadataLifecycleState) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s PodPathSelectorMetadataLifecycleState) WithValue(value meta.Lifecycle_State) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataLifecycleBlockDeletion struct{}

func (PodPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s PodPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataServices struct{}

func (PodPathSelectorMetadataServices) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().FieldPath(),
	}
}

func (s PodPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

func (PodPathSelectorMetadataServices) OwningService() PodPathSelectorMetadataServicesOwningService {
	return PodPathSelectorMetadataServicesOwningService{}
}

func (PodPathSelectorMetadataServices) AllowedServices() PodPathSelectorMetadataServicesAllowedServices {
	return PodPathSelectorMetadataServicesAllowedServices{}
}

type PodPathSelectorMetadataServicesOwningService struct{}

func (PodPathSelectorMetadataServicesOwningService) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().OwningService().FieldPath(),
	}
}

func (s PodPathSelectorMetadataServicesOwningService) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorMetadataServicesAllowedServices struct{}

func (PodPathSelectorMetadataServicesAllowedServices) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().AllowedServices().FieldPath(),
	}
}

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

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

func (s PodPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

type PodPathSelectorSpec struct{}

func (PodPathSelectorSpec) FieldPath() *Pod_FieldTerminalPath {
	return &Pod_FieldTerminalPath{selector: Pod_FieldPathSelectorSpec}
}

func (s PodPathSelectorSpec) WithValue(value *common.PodSpec) *Pod_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldTerminalPathValue)
}

func (s PodPathSelectorSpec) WithArrayOfValues(values []*common.PodSpec) *Pod_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldTerminalPathArrayOfValues)
}

func (PodPathSelectorSpec) WithSubPath(subPath common.PodSpec_FieldPath) *Pod_FieldSubPath {
	return &Pod_FieldSubPath{selector: Pod_FieldPathSelectorSpec, subPath: subPath}
}

func (s PodPathSelectorSpec) WithSubValue(subPathValue common.PodSpec_FieldPathValue) *Pod_FieldSubPathValue {
	return &Pod_FieldSubPathValue{Pod_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodPathSelectorSpec) WithSubArrayOfValues(subPathArrayOfValues common.PodSpec_FieldPathArrayOfValues) *Pod_FieldSubPathArrayOfValues {
	return &Pod_FieldSubPathArrayOfValues{Pod_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodPathSelectorSpec) WithSubArrayItemValue(subPathArrayItemValue common.PodSpec_FieldPathArrayItemValue) *Pod_FieldSubPathArrayItemValue {
	return &Pod_FieldSubPathArrayItemValue{Pod_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodPathSelectorSpec) Node() PodPathSelectorSpecNode {
	return PodPathSelectorSpecNode{}
}

func (PodPathSelectorSpec) Containers() PodPathSelectorSpecContainers {
	return PodPathSelectorSpecContainers{}
}

func (PodPathSelectorSpec) HostNetwork() PodPathSelectorSpecHostNetwork {
	return PodPathSelectorSpecHostNetwork{}
}

func (PodPathSelectorSpec) RestartPolicy() PodPathSelectorSpecRestartPolicy {
	return PodPathSelectorSpecRestartPolicy{}
}

func (PodPathSelectorSpec) ImagePullSecrets() PodPathSelectorSpecImagePullSecrets {
	return PodPathSelectorSpecImagePullSecrets{}
}

func (PodPathSelectorSpec) Volumes() PodPathSelectorSpecVolumes {
	return PodPathSelectorSpecVolumes{}
}

func (PodPathSelectorSpec) Compose() PodPathSelectorSpecCompose {
	return PodPathSelectorSpecCompose{}
}

func (PodPathSelectorSpec) HostVolumeMounts() PodPathSelectorSpecHostVolumeMounts {
	return PodPathSelectorSpecHostVolumeMounts{}
}

type PodPathSelectorSpecNode struct{}

func (PodPathSelectorSpecNode) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Node().FieldPath(),
	}
}

func (s PodPathSelectorSpecNode) WithValue(value *devices_device.Reference) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecNode) WithArrayOfValues(values []*devices_device.Reference) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

type PodPathSelectorSpecContainers struct{}

func (PodPathSelectorSpecContainers) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainers) WithValue(value []*common.PodSpec_Container) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainers) WithArrayOfValues(values [][]*common.PodSpec_Container) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecContainers) WithItemValue(value *common.PodSpec_Container) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecContainers) Args() PodPathSelectorSpecContainersArgs {
	return PodPathSelectorSpecContainersArgs{}
}

func (PodPathSelectorSpecContainers) Command() PodPathSelectorSpecContainersCommand {
	return PodPathSelectorSpecContainersCommand{}
}

func (PodPathSelectorSpecContainers) Env() PodPathSelectorSpecContainersEnv {
	return PodPathSelectorSpecContainersEnv{}
}

func (PodPathSelectorSpecContainers) Image() PodPathSelectorSpecContainersImage {
	return PodPathSelectorSpecContainersImage{}
}

func (PodPathSelectorSpecContainers) ImagePullPolicy() PodPathSelectorSpecContainersImagePullPolicy {
	return PodPathSelectorSpecContainersImagePullPolicy{}
}

func (PodPathSelectorSpecContainers) Name() PodPathSelectorSpecContainersName {
	return PodPathSelectorSpecContainersName{}
}

func (PodPathSelectorSpecContainers) Resources() PodPathSelectorSpecContainersResources {
	return PodPathSelectorSpecContainersResources{}
}

func (PodPathSelectorSpecContainers) SecurityContext() PodPathSelectorSpecContainersSecurityContext {
	return PodPathSelectorSpecContainersSecurityContext{}
}

func (PodPathSelectorSpecContainers) VolumeMounts() PodPathSelectorSpecContainersVolumeMounts {
	return PodPathSelectorSpecContainersVolumeMounts{}
}

func (PodPathSelectorSpecContainers) EnvFrom() PodPathSelectorSpecContainersEnvFrom {
	return PodPathSelectorSpecContainersEnvFrom{}
}

type PodPathSelectorSpecContainersArgs struct{}

func (PodPathSelectorSpecContainersArgs) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Args().FieldPath(),
	}
}

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

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

func (s PodPathSelectorSpecContainersArgs) WithItemValue(value string) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

type PodPathSelectorSpecContainersCommand struct{}

func (PodPathSelectorSpecContainersCommand) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Command().FieldPath(),
	}
}

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

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

func (s PodPathSelectorSpecContainersCommand) WithItemValue(value string) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

type PodPathSelectorSpecContainersEnv struct{}

func (PodPathSelectorSpecContainersEnv) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnv) WithValue(value []*common.EnvVar) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnv) WithArrayOfValues(values [][]*common.EnvVar) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecContainersEnv) WithItemValue(value *common.EnvVar) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecContainersEnv) Name() PodPathSelectorSpecContainersEnvName {
	return PodPathSelectorSpecContainersEnvName{}
}

func (PodPathSelectorSpecContainersEnv) Value() PodPathSelectorSpecContainersEnvValue {
	return PodPathSelectorSpecContainersEnvValue{}
}

func (PodPathSelectorSpecContainersEnv) ValueFrom() PodPathSelectorSpecContainersEnvValueFrom {
	return PodPathSelectorSpecContainersEnvValueFrom{}
}

type PodPathSelectorSpecContainersEnvName struct{}

func (PodPathSelectorSpecContainersEnvName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValue struct{}

func (PodPathSelectorSpecContainersEnvValue) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().Value().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValue) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValueFrom struct{}

func (PodPathSelectorSpecContainersEnvValueFrom) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFrom) WithValue(value *common.EnvVarSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnvValueFrom) WithArrayOfValues(values []*common.EnvVarSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersEnvValueFrom) ConfigMapKeyRef() PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef {
	return PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef{}
}

func (PodPathSelectorSpecContainersEnvValueFrom) SecretKeyRef() PodPathSelectorSpecContainersEnvValueFromSecretKeyRef {
	return PodPathSelectorSpecContainersEnvValueFromSecretKeyRef{}
}

type PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef struct{}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().ConfigMapKeyRef().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef) WithValue(value *common.ConfigMapKeySelector) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef) WithArrayOfValues(values []*common.ConfigMapKeySelector) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef) Name() PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefName {
	return PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefName{}
}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef) Key() PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefKey {
	return PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefKey{}
}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRef) Optional() PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefOptional {
	return PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefOptional{}
}

type PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefName struct{}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().ConfigMapKeyRef().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefKey struct{}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefKey) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().ConfigMapKeyRef().Key().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefKey) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefOptional struct{}

func (PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefOptional) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().ConfigMapKeyRef().Optional().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromConfigMapKeyRefOptional) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValueFromSecretKeyRef struct{}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRef) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().SecretKeyRef().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromSecretKeyRef) WithValue(value *common.SecretKeySelector) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnvValueFromSecretKeyRef) WithArrayOfValues(values []*common.SecretKeySelector) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRef) Name() PodPathSelectorSpecContainersEnvValueFromSecretKeyRefName {
	return PodPathSelectorSpecContainersEnvValueFromSecretKeyRefName{}
}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRef) Key() PodPathSelectorSpecContainersEnvValueFromSecretKeyRefKey {
	return PodPathSelectorSpecContainersEnvValueFromSecretKeyRefKey{}
}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRef) Optional() PodPathSelectorSpecContainersEnvValueFromSecretKeyRefOptional {
	return PodPathSelectorSpecContainersEnvValueFromSecretKeyRefOptional{}
}

type PodPathSelectorSpecContainersEnvValueFromSecretKeyRefName struct{}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRefName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().SecretKeyRef().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromSecretKeyRefName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValueFromSecretKeyRefKey struct{}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRefKey) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().SecretKeyRef().Key().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromSecretKeyRefKey) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvValueFromSecretKeyRefOptional struct{}

func (PodPathSelectorSpecContainersEnvValueFromSecretKeyRefOptional) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Env().ValueFrom().SecretKeyRef().Optional().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvValueFromSecretKeyRefOptional) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersImage struct{}

func (PodPathSelectorSpecContainersImage) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Image().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersImage) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersImagePullPolicy struct{}

func (PodPathSelectorSpecContainersImagePullPolicy) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().ImagePullPolicy().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersImagePullPolicy) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersName struct{}

func (PodPathSelectorSpecContainersName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersResources struct{}

func (PodPathSelectorSpecContainersResources) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Resources().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersResources) WithValue(value *common.PodSpec_Container_ResourceRequirements) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersResources) WithArrayOfValues(values []*common.PodSpec_Container_ResourceRequirements) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersResources) Limits() PodPathSelectorSpecContainersResourcesLimits {
	return PodPathSelectorSpecContainersResourcesLimits{}
}

func (PodPathSelectorSpecContainersResources) Requests() PodPathSelectorSpecContainersResourcesRequests {
	return PodPathSelectorSpecContainersResourcesRequests{}
}

type PodPathSelectorSpecContainersResourcesLimits struct{}

func (PodPathSelectorSpecContainersResourcesLimits) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Resources().Limits().FieldPath(),
	}
}

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

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

func (PodPathSelectorSpecContainersResourcesLimits) WithKey(key string) PodMapPathSelectorSpecContainersResourcesLimits {
	return PodMapPathSelectorSpecContainersResourcesLimits{key: key}
}

type PodMapPathSelectorSpecContainersResourcesLimits struct {
	key string
}

func (s PodMapPathSelectorSpecContainersResourcesLimits) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Resources().Limits().WithKey(s.key).FieldPath(),
	}
}

func (s PodMapPathSelectorSpecContainersResourcesLimits) WithValue(value int64) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersResourcesRequests struct{}

func (PodPathSelectorSpecContainersResourcesRequests) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Resources().Requests().FieldPath(),
	}
}

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

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

func (PodPathSelectorSpecContainersResourcesRequests) WithKey(key string) PodMapPathSelectorSpecContainersResourcesRequests {
	return PodMapPathSelectorSpecContainersResourcesRequests{key: key}
}

type PodMapPathSelectorSpecContainersResourcesRequests struct {
	key string
}

func (s PodMapPathSelectorSpecContainersResourcesRequests) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().Resources().Requests().WithKey(s.key).FieldPath(),
	}
}

func (s PodMapPathSelectorSpecContainersResourcesRequests) WithValue(value int64) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersSecurityContext struct{}

func (PodPathSelectorSpecContainersSecurityContext) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().SecurityContext().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersSecurityContext) WithValue(value *common.SecurityContext) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersSecurityContext) WithArrayOfValues(values []*common.SecurityContext) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersSecurityContext) Privileged() PodPathSelectorSpecContainersSecurityContextPrivileged {
	return PodPathSelectorSpecContainersSecurityContextPrivileged{}
}

type PodPathSelectorSpecContainersSecurityContextPrivileged struct{}

func (PodPathSelectorSpecContainersSecurityContextPrivileged) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().SecurityContext().Privileged().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersSecurityContextPrivileged) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersVolumeMounts struct{}

func (PodPathSelectorSpecContainersVolumeMounts) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().VolumeMounts().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersVolumeMounts) WithValue(value []*common.VolumeMount) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersVolumeMounts) WithArrayOfValues(values [][]*common.VolumeMount) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecContainersVolumeMounts) WithItemValue(value *common.VolumeMount) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecContainersVolumeMounts) Name() PodPathSelectorSpecContainersVolumeMountsName {
	return PodPathSelectorSpecContainersVolumeMountsName{}
}

func (PodPathSelectorSpecContainersVolumeMounts) ReadOnly() PodPathSelectorSpecContainersVolumeMountsReadOnly {
	return PodPathSelectorSpecContainersVolumeMountsReadOnly{}
}

func (PodPathSelectorSpecContainersVolumeMounts) MountPath() PodPathSelectorSpecContainersVolumeMountsMountPath {
	return PodPathSelectorSpecContainersVolumeMountsMountPath{}
}

func (PodPathSelectorSpecContainersVolumeMounts) SubPath() PodPathSelectorSpecContainersVolumeMountsSubPath {
	return PodPathSelectorSpecContainersVolumeMountsSubPath{}
}

type PodPathSelectorSpecContainersVolumeMountsName struct{}

func (PodPathSelectorSpecContainersVolumeMountsName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().VolumeMounts().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersVolumeMountsName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersVolumeMountsReadOnly struct{}

func (PodPathSelectorSpecContainersVolumeMountsReadOnly) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().VolumeMounts().ReadOnly().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersVolumeMountsReadOnly) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersVolumeMountsMountPath struct{}

func (PodPathSelectorSpecContainersVolumeMountsMountPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().VolumeMounts().MountPath().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersVolumeMountsMountPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersVolumeMountsSubPath struct{}

func (PodPathSelectorSpecContainersVolumeMountsSubPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().VolumeMounts().SubPath().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersVolumeMountsSubPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvFrom struct{}

func (PodPathSelectorSpecContainersEnvFrom) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFrom) WithValue(value *common.EnvFromSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnvFrom) WithArrayOfValues(values []*common.EnvFromSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersEnvFrom) Prefix() PodPathSelectorSpecContainersEnvFromPrefix {
	return PodPathSelectorSpecContainersEnvFromPrefix{}
}

func (PodPathSelectorSpecContainersEnvFrom) ConfigMapRef() PodPathSelectorSpecContainersEnvFromConfigMapRef {
	return PodPathSelectorSpecContainersEnvFromConfigMapRef{}
}

func (PodPathSelectorSpecContainersEnvFrom) SecretRef() PodPathSelectorSpecContainersEnvFromSecretRef {
	return PodPathSelectorSpecContainersEnvFromSecretRef{}
}

type PodPathSelectorSpecContainersEnvFromPrefix struct{}

func (PodPathSelectorSpecContainersEnvFromPrefix) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().Prefix().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromPrefix) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvFromConfigMapRef struct{}

func (PodPathSelectorSpecContainersEnvFromConfigMapRef) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().ConfigMapRef().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromConfigMapRef) WithValue(value *common.ConfigMapEnvSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnvFromConfigMapRef) WithArrayOfValues(values []*common.ConfigMapEnvSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersEnvFromConfigMapRef) Name() PodPathSelectorSpecContainersEnvFromConfigMapRefName {
	return PodPathSelectorSpecContainersEnvFromConfigMapRefName{}
}

func (PodPathSelectorSpecContainersEnvFromConfigMapRef) Optional() PodPathSelectorSpecContainersEnvFromConfigMapRefOptional {
	return PodPathSelectorSpecContainersEnvFromConfigMapRefOptional{}
}

type PodPathSelectorSpecContainersEnvFromConfigMapRefName struct{}

func (PodPathSelectorSpecContainersEnvFromConfigMapRefName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().ConfigMapRef().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromConfigMapRefName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvFromConfigMapRefOptional struct{}

func (PodPathSelectorSpecContainersEnvFromConfigMapRefOptional) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().ConfigMapRef().Optional().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromConfigMapRefOptional) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvFromSecretRef struct{}

func (PodPathSelectorSpecContainersEnvFromSecretRef) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().SecretRef().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromSecretRef) WithValue(value *common.SecretEnvSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecContainersEnvFromSecretRef) WithArrayOfValues(values []*common.SecretEnvSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecContainersEnvFromSecretRef) Name() PodPathSelectorSpecContainersEnvFromSecretRefName {
	return PodPathSelectorSpecContainersEnvFromSecretRefName{}
}

func (PodPathSelectorSpecContainersEnvFromSecretRef) Optional() PodPathSelectorSpecContainersEnvFromSecretRefOptional {
	return PodPathSelectorSpecContainersEnvFromSecretRefOptional{}
}

type PodPathSelectorSpecContainersEnvFromSecretRefName struct{}

func (PodPathSelectorSpecContainersEnvFromSecretRefName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().SecretRef().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromSecretRefName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecContainersEnvFromSecretRefOptional struct{}

func (PodPathSelectorSpecContainersEnvFromSecretRefOptional) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Containers().EnvFrom().SecretRef().Optional().FieldPath(),
	}
}

func (s PodPathSelectorSpecContainersEnvFromSecretRefOptional) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecHostNetwork struct{}

func (PodPathSelectorSpecHostNetwork) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().HostNetwork().FieldPath(),
	}
}

func (s PodPathSelectorSpecHostNetwork) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecRestartPolicy struct{}

func (PodPathSelectorSpecRestartPolicy) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().RestartPolicy().FieldPath(),
	}
}

func (s PodPathSelectorSpecRestartPolicy) WithValue(value common.PodSpec_RestartPolicy) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecRestartPolicy) WithArrayOfValues(values []common.PodSpec_RestartPolicy) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

type PodPathSelectorSpecImagePullSecrets struct{}

func (PodPathSelectorSpecImagePullSecrets) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().ImagePullSecrets().FieldPath(),
	}
}

func (s PodPathSelectorSpecImagePullSecrets) WithValue(value []*common.LocalObjectReferenceSecret) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecImagePullSecrets) WithArrayOfValues(values [][]*common.LocalObjectReferenceSecret) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecImagePullSecrets) WithItemValue(value *common.LocalObjectReferenceSecret) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecImagePullSecrets) Name() PodPathSelectorSpecImagePullSecretsName {
	return PodPathSelectorSpecImagePullSecretsName{}
}

type PodPathSelectorSpecImagePullSecretsName struct{}

func (PodPathSelectorSpecImagePullSecretsName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().ImagePullSecrets().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecImagePullSecretsName) WithValue(value *secrets_secret.Reference) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecImagePullSecretsName) WithArrayOfValues(values []*secrets_secret.Reference) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

type PodPathSelectorSpecVolumes struct{}

func (PodPathSelectorSpecVolumes) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumes) WithValue(value []*common.Volume) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumes) WithArrayOfValues(values [][]*common.Volume) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecVolumes) WithItemValue(value *common.Volume) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecVolumes) Name() PodPathSelectorSpecVolumesName {
	return PodPathSelectorSpecVolumesName{}
}

func (PodPathSelectorSpecVolumes) HostPath() PodPathSelectorSpecVolumesHostPath {
	return PodPathSelectorSpecVolumesHostPath{}
}

func (PodPathSelectorSpecVolumes) Secret() PodPathSelectorSpecVolumesSecret {
	return PodPathSelectorSpecVolumesSecret{}
}

func (PodPathSelectorSpecVolumes) ConfigMap() PodPathSelectorSpecVolumesConfigMap {
	return PodPathSelectorSpecVolumesConfigMap{}
}

type PodPathSelectorSpecVolumesName struct{}

func (PodPathSelectorSpecVolumesName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesHostPath struct{}

func (PodPathSelectorSpecVolumesHostPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().HostPath().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesHostPath) WithValue(value *common.HostPathVolumeSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumesHostPath) WithArrayOfValues(values []*common.HostPathVolumeSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecVolumesHostPath) Path() PodPathSelectorSpecVolumesHostPathPath {
	return PodPathSelectorSpecVolumesHostPathPath{}
}

func (PodPathSelectorSpecVolumesHostPath) Type() PodPathSelectorSpecVolumesHostPathType {
	return PodPathSelectorSpecVolumesHostPathType{}
}

type PodPathSelectorSpecVolumesHostPathPath struct{}

func (PodPathSelectorSpecVolumesHostPathPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().HostPath().Path().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesHostPathPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesHostPathType struct{}

func (PodPathSelectorSpecVolumesHostPathType) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().HostPath().Type().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesHostPathType) WithValue(value common.HostPathVolumeSource_Type) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumesHostPathType) WithArrayOfValues(values []common.HostPathVolumeSource_Type) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

type PodPathSelectorSpecVolumesSecret struct{}

func (PodPathSelectorSpecVolumesSecret) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecret) WithValue(value *common.SecretVolumeSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumesSecret) WithArrayOfValues(values []*common.SecretVolumeSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecVolumesSecret) SecretName() PodPathSelectorSpecVolumesSecretSecretName {
	return PodPathSelectorSpecVolumesSecretSecretName{}
}

func (PodPathSelectorSpecVolumesSecret) Items() PodPathSelectorSpecVolumesSecretItems {
	return PodPathSelectorSpecVolumesSecretItems{}
}

func (PodPathSelectorSpecVolumesSecret) DefaultMode() PodPathSelectorSpecVolumesSecretDefaultMode {
	return PodPathSelectorSpecVolumesSecretDefaultMode{}
}

func (PodPathSelectorSpecVolumesSecret) Optional() PodPathSelectorSpecVolumesSecretOptional {
	return PodPathSelectorSpecVolumesSecretOptional{}
}

type PodPathSelectorSpecVolumesSecretSecretName struct{}

func (PodPathSelectorSpecVolumesSecretSecretName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().SecretName().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretSecretName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesSecretItems struct{}

func (PodPathSelectorSpecVolumesSecretItems) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().Items().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretItems) WithValue(value []*common.KeyToPath) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumesSecretItems) WithArrayOfValues(values [][]*common.KeyToPath) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecVolumesSecretItems) WithItemValue(value *common.KeyToPath) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecVolumesSecretItems) Key() PodPathSelectorSpecVolumesSecretItemsKey {
	return PodPathSelectorSpecVolumesSecretItemsKey{}
}

func (PodPathSelectorSpecVolumesSecretItems) Path() PodPathSelectorSpecVolumesSecretItemsPath {
	return PodPathSelectorSpecVolumesSecretItemsPath{}
}

func (PodPathSelectorSpecVolumesSecretItems) Mode() PodPathSelectorSpecVolumesSecretItemsMode {
	return PodPathSelectorSpecVolumesSecretItemsMode{}
}

type PodPathSelectorSpecVolumesSecretItemsKey struct{}

func (PodPathSelectorSpecVolumesSecretItemsKey) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().Items().Key().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretItemsKey) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesSecretItemsPath struct{}

func (PodPathSelectorSpecVolumesSecretItemsPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().Items().Path().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretItemsPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesSecretItemsMode struct{}

func (PodPathSelectorSpecVolumesSecretItemsMode) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().Items().Mode().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretItemsMode) WithValue(value int32) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesSecretDefaultMode struct{}

func (PodPathSelectorSpecVolumesSecretDefaultMode) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().DefaultMode().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretDefaultMode) WithValue(value int32) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesSecretOptional struct{}

func (PodPathSelectorSpecVolumesSecretOptional) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().Secret().Optional().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesSecretOptional) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesConfigMap struct{}

func (PodPathSelectorSpecVolumesConfigMap) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMap) WithValue(value *common.ConfigMapVolumeSource) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumesConfigMap) WithArrayOfValues(values []*common.ConfigMapVolumeSource) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorSpecVolumesConfigMap) Name() PodPathSelectorSpecVolumesConfigMapName {
	return PodPathSelectorSpecVolumesConfigMapName{}
}

func (PodPathSelectorSpecVolumesConfigMap) Items() PodPathSelectorSpecVolumesConfigMapItems {
	return PodPathSelectorSpecVolumesConfigMapItems{}
}

func (PodPathSelectorSpecVolumesConfigMap) DefaultMode() PodPathSelectorSpecVolumesConfigMapDefaultMode {
	return PodPathSelectorSpecVolumesConfigMapDefaultMode{}
}

func (PodPathSelectorSpecVolumesConfigMap) Optional() PodPathSelectorSpecVolumesConfigMapOptional {
	return PodPathSelectorSpecVolumesConfigMapOptional{}
}

type PodPathSelectorSpecVolumesConfigMapName struct{}

func (PodPathSelectorSpecVolumesConfigMapName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesConfigMapItems struct{}

func (PodPathSelectorSpecVolumesConfigMapItems) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().Items().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapItems) WithValue(value []*common.KeyToPath) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecVolumesConfigMapItems) WithArrayOfValues(values [][]*common.KeyToPath) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecVolumesConfigMapItems) WithItemValue(value *common.KeyToPath) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecVolumesConfigMapItems) Key() PodPathSelectorSpecVolumesConfigMapItemsKey {
	return PodPathSelectorSpecVolumesConfigMapItemsKey{}
}

func (PodPathSelectorSpecVolumesConfigMapItems) Path() PodPathSelectorSpecVolumesConfigMapItemsPath {
	return PodPathSelectorSpecVolumesConfigMapItemsPath{}
}

func (PodPathSelectorSpecVolumesConfigMapItems) Mode() PodPathSelectorSpecVolumesConfigMapItemsMode {
	return PodPathSelectorSpecVolumesConfigMapItemsMode{}
}

type PodPathSelectorSpecVolumesConfigMapItemsKey struct{}

func (PodPathSelectorSpecVolumesConfigMapItemsKey) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().Items().Key().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapItemsKey) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesConfigMapItemsPath struct{}

func (PodPathSelectorSpecVolumesConfigMapItemsPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().Items().Path().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapItemsPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesConfigMapItemsMode struct{}

func (PodPathSelectorSpecVolumesConfigMapItemsMode) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().Items().Mode().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapItemsMode) WithValue(value int32) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesConfigMapDefaultMode struct{}

func (PodPathSelectorSpecVolumesConfigMapDefaultMode) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().DefaultMode().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapDefaultMode) WithValue(value int32) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecVolumesConfigMapOptional struct{}

func (PodPathSelectorSpecVolumesConfigMapOptional) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Volumes().ConfigMap().Optional().FieldPath(),
	}
}

func (s PodPathSelectorSpecVolumesConfigMapOptional) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecCompose struct{}

func (PodPathSelectorSpecCompose) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().Compose().FieldPath(),
	}
}

func (s PodPathSelectorSpecCompose) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecHostVolumeMounts struct{}

func (PodPathSelectorSpecHostVolumeMounts) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().HostVolumeMounts().FieldPath(),
	}
}

func (s PodPathSelectorSpecHostVolumeMounts) WithValue(value []*common.VolumeMount) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorSpecHostVolumeMounts) WithArrayOfValues(values [][]*common.VolumeMount) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorSpecHostVolumeMounts) WithItemValue(value *common.VolumeMount) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorSpecHostVolumeMounts) Name() PodPathSelectorSpecHostVolumeMountsName {
	return PodPathSelectorSpecHostVolumeMountsName{}
}

func (PodPathSelectorSpecHostVolumeMounts) ReadOnly() PodPathSelectorSpecHostVolumeMountsReadOnly {
	return PodPathSelectorSpecHostVolumeMountsReadOnly{}
}

func (PodPathSelectorSpecHostVolumeMounts) MountPath() PodPathSelectorSpecHostVolumeMountsMountPath {
	return PodPathSelectorSpecHostVolumeMountsMountPath{}
}

func (PodPathSelectorSpecHostVolumeMounts) SubPath() PodPathSelectorSpecHostVolumeMountsSubPath {
	return PodPathSelectorSpecHostVolumeMountsSubPath{}
}

type PodPathSelectorSpecHostVolumeMountsName struct{}

func (PodPathSelectorSpecHostVolumeMountsName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().HostVolumeMounts().Name().FieldPath(),
	}
}

func (s PodPathSelectorSpecHostVolumeMountsName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecHostVolumeMountsReadOnly struct{}

func (PodPathSelectorSpecHostVolumeMountsReadOnly) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().HostVolumeMounts().ReadOnly().FieldPath(),
	}
}

func (s PodPathSelectorSpecHostVolumeMountsReadOnly) WithValue(value bool) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecHostVolumeMountsMountPath struct{}

func (PodPathSelectorSpecHostVolumeMountsMountPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().HostVolumeMounts().MountPath().FieldPath(),
	}
}

func (s PodPathSelectorSpecHostVolumeMountsMountPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorSpecHostVolumeMountsSubPath struct{}

func (PodPathSelectorSpecHostVolumeMountsSubPath) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorSpec,
		subPath:  common.NewPodSpecFieldPathBuilder().HostVolumeMounts().SubPath().FieldPath(),
	}
}

func (s PodPathSelectorSpecHostVolumeMountsSubPath) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorDistribution struct{}

func (PodPathSelectorDistribution) FieldPath() *Pod_FieldTerminalPath {
	return &Pod_FieldTerminalPath{selector: Pod_FieldPathSelectorDistribution}
}

func (s PodPathSelectorDistribution) WithValue(value *distribution.Reference) *Pod_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldTerminalPathValue)
}

func (s PodPathSelectorDistribution) WithArrayOfValues(values []*distribution.Reference) *Pod_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldTerminalPathArrayOfValues)
}

type PodPathSelectorStatus struct{}

func (PodPathSelectorStatus) FieldPath() *Pod_FieldTerminalPath {
	return &Pod_FieldTerminalPath{selector: Pod_FieldPathSelectorStatus}
}

func (s PodPathSelectorStatus) WithValue(value *Pod_Status) *Pod_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldTerminalPathValue)
}

func (s PodPathSelectorStatus) WithArrayOfValues(values []*Pod_Status) *Pod_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldTerminalPathArrayOfValues)
}

func (PodPathSelectorStatus) WithSubPath(subPath PodStatus_FieldPath) *Pod_FieldSubPath {
	return &Pod_FieldSubPath{selector: Pod_FieldPathSelectorStatus, subPath: subPath}
}

func (s PodPathSelectorStatus) WithSubValue(subPathValue PodStatus_FieldPathValue) *Pod_FieldSubPathValue {
	return &Pod_FieldSubPathValue{Pod_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodPathSelectorStatus) WithSubArrayOfValues(subPathArrayOfValues PodStatus_FieldPathArrayOfValues) *Pod_FieldSubPathArrayOfValues {
	return &Pod_FieldSubPathArrayOfValues{Pod_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodPathSelectorStatus) WithSubArrayItemValue(subPathArrayItemValue PodStatus_FieldPathArrayItemValue) *Pod_FieldSubPathArrayItemValue {
	return &Pod_FieldSubPathArrayItemValue{Pod_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodPathSelectorStatus) Phase() PodPathSelectorStatusPhase {
	return PodPathSelectorStatusPhase{}
}

func (PodPathSelectorStatus) ContainerStatuses() PodPathSelectorStatusContainerStatuses {
	return PodPathSelectorStatusContainerStatuses{}
}

func (PodPathSelectorStatus) Error() PodPathSelectorStatusError {
	return PodPathSelectorStatusError{}
}

type PodPathSelectorStatusPhase struct{}

func (PodPathSelectorStatusPhase) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().Phase().FieldPath(),
	}
}

func (s PodPathSelectorStatusPhase) WithValue(value Pod_Status_Phase) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorStatusPhase) WithArrayOfValues(values []Pod_Status_Phase) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

type PodPathSelectorStatusContainerStatuses struct{}

func (PodPathSelectorStatusContainerStatuses) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatuses) WithValue(value []*Pod_Status_Container) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorStatusContainerStatuses) WithArrayOfValues(values [][]*Pod_Status_Container) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (s PodPathSelectorStatusContainerStatuses) WithItemValue(value *Pod_Status_Container) *Pod_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Pod_FieldSubPathArrayItemValue)
}

func (PodPathSelectorStatusContainerStatuses) Name() PodPathSelectorStatusContainerStatusesName {
	return PodPathSelectorStatusContainerStatusesName{}
}

func (PodPathSelectorStatusContainerStatuses) State() PodPathSelectorStatusContainerStatusesState {
	return PodPathSelectorStatusContainerStatusesState{}
}

func (PodPathSelectorStatusContainerStatuses) Waiting() PodPathSelectorStatusContainerStatusesWaiting {
	return PodPathSelectorStatusContainerStatusesWaiting{}
}

func (PodPathSelectorStatusContainerStatuses) Running() PodPathSelectorStatusContainerStatusesRunning {
	return PodPathSelectorStatusContainerStatusesRunning{}
}

func (PodPathSelectorStatusContainerStatuses) Terminated() PodPathSelectorStatusContainerStatusesTerminated {
	return PodPathSelectorStatusContainerStatusesTerminated{}
}

type PodPathSelectorStatusContainerStatusesName struct{}

func (PodPathSelectorStatusContainerStatusesName) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Name().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesName) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesState struct{}

func (PodPathSelectorStatusContainerStatusesState) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().State().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesState) WithValue(value Pod_Status_Container_State) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorStatusContainerStatusesState) WithArrayOfValues(values []Pod_Status_Container_State) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

type PodPathSelectorStatusContainerStatusesWaiting struct{}

func (PodPathSelectorStatusContainerStatusesWaiting) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Waiting().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesWaiting) WithValue(value *Pod_Status_Container_StateWaiting) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorStatusContainerStatusesWaiting) WithArrayOfValues(values []*Pod_Status_Container_StateWaiting) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorStatusContainerStatusesWaiting) Reason() PodPathSelectorStatusContainerStatusesWaitingReason {
	return PodPathSelectorStatusContainerStatusesWaitingReason{}
}

func (PodPathSelectorStatusContainerStatusesWaiting) Message() PodPathSelectorStatusContainerStatusesWaitingMessage {
	return PodPathSelectorStatusContainerStatusesWaitingMessage{}
}

type PodPathSelectorStatusContainerStatusesWaitingReason struct{}

func (PodPathSelectorStatusContainerStatusesWaitingReason) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Waiting().Reason().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesWaitingReason) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesWaitingMessage struct{}

func (PodPathSelectorStatusContainerStatusesWaitingMessage) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Waiting().Message().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesWaitingMessage) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesRunning struct{}

func (PodPathSelectorStatusContainerStatusesRunning) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Running().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesRunning) WithValue(value *Pod_Status_Container_StateRunning) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorStatusContainerStatusesRunning) WithArrayOfValues(values []*Pod_Status_Container_StateRunning) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorStatusContainerStatusesRunning) StartedAt() PodPathSelectorStatusContainerStatusesRunningStartedAt {
	return PodPathSelectorStatusContainerStatusesRunningStartedAt{}
}

type PodPathSelectorStatusContainerStatusesRunningStartedAt struct{}

func (PodPathSelectorStatusContainerStatusesRunningStartedAt) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Running().StartedAt().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesRunningStartedAt) WithValue(value *timestamppb.Timestamp) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminated struct{}

func (PodPathSelectorStatusContainerStatusesTerminated) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminated) WithValue(value *Pod_Status_Container_StateTerminated) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

func (s PodPathSelectorStatusContainerStatusesTerminated) WithArrayOfValues(values []*Pod_Status_Container_StateTerminated) *Pod_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Pod_FieldSubPathArrayOfValues)
}

func (PodPathSelectorStatusContainerStatusesTerminated) ExitCode() PodPathSelectorStatusContainerStatusesTerminatedExitCode {
	return PodPathSelectorStatusContainerStatusesTerminatedExitCode{}
}

func (PodPathSelectorStatusContainerStatusesTerminated) Signal() PodPathSelectorStatusContainerStatusesTerminatedSignal {
	return PodPathSelectorStatusContainerStatusesTerminatedSignal{}
}

func (PodPathSelectorStatusContainerStatusesTerminated) Reason() PodPathSelectorStatusContainerStatusesTerminatedReason {
	return PodPathSelectorStatusContainerStatusesTerminatedReason{}
}

func (PodPathSelectorStatusContainerStatusesTerminated) Message() PodPathSelectorStatusContainerStatusesTerminatedMessage {
	return PodPathSelectorStatusContainerStatusesTerminatedMessage{}
}

func (PodPathSelectorStatusContainerStatusesTerminated) StartedAt() PodPathSelectorStatusContainerStatusesTerminatedStartedAt {
	return PodPathSelectorStatusContainerStatusesTerminatedStartedAt{}
}

func (PodPathSelectorStatusContainerStatusesTerminated) FinishedAt() PodPathSelectorStatusContainerStatusesTerminatedFinishedAt {
	return PodPathSelectorStatusContainerStatusesTerminatedFinishedAt{}
}

func (PodPathSelectorStatusContainerStatusesTerminated) ContainerId() PodPathSelectorStatusContainerStatusesTerminatedContainerId {
	return PodPathSelectorStatusContainerStatusesTerminatedContainerId{}
}

type PodPathSelectorStatusContainerStatusesTerminatedExitCode struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedExitCode) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().ExitCode().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedExitCode) WithValue(value int32) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminatedSignal struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedSignal) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().Signal().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedSignal) WithValue(value int32) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminatedReason struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedReason) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().Reason().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedReason) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminatedMessage struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedMessage) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().Message().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedMessage) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminatedStartedAt struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedStartedAt) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().StartedAt().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedStartedAt) WithValue(value *timestamppb.Timestamp) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminatedFinishedAt struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedFinishedAt) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().FinishedAt().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedFinishedAt) WithValue(value *timestamppb.Timestamp) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusContainerStatusesTerminatedContainerId struct{}

func (PodPathSelectorStatusContainerStatusesTerminatedContainerId) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().ContainerStatuses().Terminated().ContainerId().FieldPath(),
	}
}

func (s PodPathSelectorStatusContainerStatusesTerminatedContainerId) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodPathSelectorStatusError struct{}

func (PodPathSelectorStatusError) FieldPath() *Pod_FieldSubPath {
	return &Pod_FieldSubPath{
		selector: Pod_FieldPathSelectorStatus,
		subPath:  NewPodStatusFieldPathBuilder().Error().FieldPath(),
	}
}

func (s PodPathSelectorStatusError) WithValue(value string) *Pod_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Pod_FieldSubPathValue)
}

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

type PodStatusFieldPathBuilder struct{}

func NewPodStatusFieldPathBuilder() PodStatusFieldPathBuilder {
	return PodStatusFieldPathBuilder{}
}
func (PodStatusFieldPathBuilder) Phase() Pod_StatusPathSelectorPhase {
	return Pod_StatusPathSelectorPhase{}
}
func (PodStatusFieldPathBuilder) ContainerStatuses() Pod_StatusPathSelectorContainerStatuses {
	return Pod_StatusPathSelectorContainerStatuses{}
}
func (PodStatusFieldPathBuilder) Error() Pod_StatusPathSelectorError {
	return Pod_StatusPathSelectorError{}
}

type Pod_StatusPathSelectorPhase struct{}

func (Pod_StatusPathSelectorPhase) FieldPath() *PodStatus_FieldTerminalPath {
	return &PodStatus_FieldTerminalPath{selector: PodStatus_FieldPathSelectorPhase}
}

func (s Pod_StatusPathSelectorPhase) WithValue(value Pod_Status_Phase) *PodStatus_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldTerminalPathValue)
}

func (s Pod_StatusPathSelectorPhase) WithArrayOfValues(values []Pod_Status_Phase) *PodStatus_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatus_FieldTerminalPathArrayOfValues)
}

type Pod_StatusPathSelectorContainerStatuses struct{}

func (Pod_StatusPathSelectorContainerStatuses) FieldPath() *PodStatus_FieldTerminalPath {
	return &PodStatus_FieldTerminalPath{selector: PodStatus_FieldPathSelectorContainerStatuses}
}

func (s Pod_StatusPathSelectorContainerStatuses) WithValue(value []*Pod_Status_Container) *PodStatus_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldTerminalPathValue)
}

func (s Pod_StatusPathSelectorContainerStatuses) WithArrayOfValues(values [][]*Pod_Status_Container) *PodStatus_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatus_FieldTerminalPathArrayOfValues)
}

func (s Pod_StatusPathSelectorContainerStatuses) WithItemValue(value *Pod_Status_Container) *PodStatus_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodStatus_FieldTerminalPathArrayItemValue)
}
func (Pod_StatusPathSelectorContainerStatuses) WithSubPath(subPath PodStatusContainer_FieldPath) *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{selector: PodStatus_FieldPathSelectorContainerStatuses, subPath: subPath}
}

func (s Pod_StatusPathSelectorContainerStatuses) WithSubValue(subPathValue PodStatusContainer_FieldPathValue) *PodStatus_FieldSubPathValue {
	return &PodStatus_FieldSubPathValue{PodStatus_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Pod_StatusPathSelectorContainerStatuses) WithSubArrayOfValues(subPathArrayOfValues PodStatusContainer_FieldPathArrayOfValues) *PodStatus_FieldSubPathArrayOfValues {
	return &PodStatus_FieldSubPathArrayOfValues{PodStatus_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Pod_StatusPathSelectorContainerStatuses) WithSubArrayItemValue(subPathArrayItemValue PodStatusContainer_FieldPathArrayItemValue) *PodStatus_FieldSubPathArrayItemValue {
	return &PodStatus_FieldSubPathArrayItemValue{PodStatus_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Pod_StatusPathSelectorContainerStatuses) Name() Pod_StatusPathSelectorContainerStatusesName {
	return Pod_StatusPathSelectorContainerStatusesName{}
}

func (Pod_StatusPathSelectorContainerStatuses) State() Pod_StatusPathSelectorContainerStatusesState {
	return Pod_StatusPathSelectorContainerStatusesState{}
}

func (Pod_StatusPathSelectorContainerStatuses) Waiting() Pod_StatusPathSelectorContainerStatusesWaiting {
	return Pod_StatusPathSelectorContainerStatusesWaiting{}
}

func (Pod_StatusPathSelectorContainerStatuses) Running() Pod_StatusPathSelectorContainerStatusesRunning {
	return Pod_StatusPathSelectorContainerStatusesRunning{}
}

func (Pod_StatusPathSelectorContainerStatuses) Terminated() Pod_StatusPathSelectorContainerStatusesTerminated {
	return Pod_StatusPathSelectorContainerStatusesTerminated{}
}

type Pod_StatusPathSelectorContainerStatusesName struct{}

func (Pod_StatusPathSelectorContainerStatusesName) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Name().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesName) WithValue(value string) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesState struct{}

func (Pod_StatusPathSelectorContainerStatusesState) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().State().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesState) WithValue(value Pod_Status_Container_State) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

func (s Pod_StatusPathSelectorContainerStatusesState) WithArrayOfValues(values []Pod_Status_Container_State) *PodStatus_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatus_FieldSubPathArrayOfValues)
}

type Pod_StatusPathSelectorContainerStatusesWaiting struct{}

func (Pod_StatusPathSelectorContainerStatusesWaiting) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Waiting().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesWaiting) WithValue(value *Pod_Status_Container_StateWaiting) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

func (s Pod_StatusPathSelectorContainerStatusesWaiting) WithArrayOfValues(values []*Pod_Status_Container_StateWaiting) *PodStatus_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatus_FieldSubPathArrayOfValues)
}

func (Pod_StatusPathSelectorContainerStatusesWaiting) Reason() Pod_StatusPathSelectorContainerStatusesWaitingReason {
	return Pod_StatusPathSelectorContainerStatusesWaitingReason{}
}

func (Pod_StatusPathSelectorContainerStatusesWaiting) Message() Pod_StatusPathSelectorContainerStatusesWaitingMessage {
	return Pod_StatusPathSelectorContainerStatusesWaitingMessage{}
}

type Pod_StatusPathSelectorContainerStatusesWaitingReason struct{}

func (Pod_StatusPathSelectorContainerStatusesWaitingReason) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Waiting().Reason().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesWaitingReason) WithValue(value string) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesWaitingMessage struct{}

func (Pod_StatusPathSelectorContainerStatusesWaitingMessage) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Waiting().Message().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesWaitingMessage) WithValue(value string) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesRunning struct{}

func (Pod_StatusPathSelectorContainerStatusesRunning) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Running().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesRunning) WithValue(value *Pod_Status_Container_StateRunning) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

func (s Pod_StatusPathSelectorContainerStatusesRunning) WithArrayOfValues(values []*Pod_Status_Container_StateRunning) *PodStatus_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatus_FieldSubPathArrayOfValues)
}

func (Pod_StatusPathSelectorContainerStatusesRunning) StartedAt() Pod_StatusPathSelectorContainerStatusesRunningStartedAt {
	return Pod_StatusPathSelectorContainerStatusesRunningStartedAt{}
}

type Pod_StatusPathSelectorContainerStatusesRunningStartedAt struct{}

func (Pod_StatusPathSelectorContainerStatusesRunningStartedAt) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Running().StartedAt().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesRunningStartedAt) WithValue(value *timestamppb.Timestamp) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminated struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminated) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminated) WithValue(value *Pod_Status_Container_StateTerminated) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

func (s Pod_StatusPathSelectorContainerStatusesTerminated) WithArrayOfValues(values []*Pod_Status_Container_StateTerminated) *PodStatus_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatus_FieldSubPathArrayOfValues)
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) ExitCode() Pod_StatusPathSelectorContainerStatusesTerminatedExitCode {
	return Pod_StatusPathSelectorContainerStatusesTerminatedExitCode{}
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) Signal() Pod_StatusPathSelectorContainerStatusesTerminatedSignal {
	return Pod_StatusPathSelectorContainerStatusesTerminatedSignal{}
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) Reason() Pod_StatusPathSelectorContainerStatusesTerminatedReason {
	return Pod_StatusPathSelectorContainerStatusesTerminatedReason{}
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) Message() Pod_StatusPathSelectorContainerStatusesTerminatedMessage {
	return Pod_StatusPathSelectorContainerStatusesTerminatedMessage{}
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) StartedAt() Pod_StatusPathSelectorContainerStatusesTerminatedStartedAt {
	return Pod_StatusPathSelectorContainerStatusesTerminatedStartedAt{}
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) FinishedAt() Pod_StatusPathSelectorContainerStatusesTerminatedFinishedAt {
	return Pod_StatusPathSelectorContainerStatusesTerminatedFinishedAt{}
}

func (Pod_StatusPathSelectorContainerStatusesTerminated) ContainerId() Pod_StatusPathSelectorContainerStatusesTerminatedContainerId {
	return Pod_StatusPathSelectorContainerStatusesTerminatedContainerId{}
}

type Pod_StatusPathSelectorContainerStatusesTerminatedExitCode struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedExitCode) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().ExitCode().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedExitCode) WithValue(value int32) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminatedSignal struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedSignal) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().Signal().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedSignal) WithValue(value int32) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminatedReason struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedReason) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().Reason().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedReason) WithValue(value string) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminatedMessage struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedMessage) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().Message().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedMessage) WithValue(value string) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminatedStartedAt struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedStartedAt) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().StartedAt().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedStartedAt) WithValue(value *timestamppb.Timestamp) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminatedFinishedAt struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedFinishedAt) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().FinishedAt().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedFinishedAt) WithValue(value *timestamppb.Timestamp) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorContainerStatusesTerminatedContainerId struct{}

func (Pod_StatusPathSelectorContainerStatusesTerminatedContainerId) FieldPath() *PodStatus_FieldSubPath {
	return &PodStatus_FieldSubPath{
		selector: PodStatus_FieldPathSelectorContainerStatuses,
		subPath:  NewPodStatusContainerFieldPathBuilder().Terminated().ContainerId().FieldPath(),
	}
}

func (s Pod_StatusPathSelectorContainerStatusesTerminatedContainerId) WithValue(value string) *PodStatus_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldSubPathValue)
}

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

type Pod_StatusPathSelectorError struct{}

func (Pod_StatusPathSelectorError) FieldPath() *PodStatus_FieldTerminalPath {
	return &PodStatus_FieldTerminalPath{selector: PodStatus_FieldPathSelectorError}
}

func (s Pod_StatusPathSelectorError) WithValue(value string) *PodStatus_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatus_FieldTerminalPathValue)
}

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

type PodStatusContainerFieldPathBuilder struct{}

func NewPodStatusContainerFieldPathBuilder() PodStatusContainerFieldPathBuilder {
	return PodStatusContainerFieldPathBuilder{}
}
func (PodStatusContainerFieldPathBuilder) Name() Pod_Status_ContainerPathSelectorName {
	return Pod_Status_ContainerPathSelectorName{}
}
func (PodStatusContainerFieldPathBuilder) State() Pod_Status_ContainerPathSelectorState {
	return Pod_Status_ContainerPathSelectorState{}
}
func (PodStatusContainerFieldPathBuilder) Waiting() Pod_Status_ContainerPathSelectorWaiting {
	return Pod_Status_ContainerPathSelectorWaiting{}
}
func (PodStatusContainerFieldPathBuilder) Running() Pod_Status_ContainerPathSelectorRunning {
	return Pod_Status_ContainerPathSelectorRunning{}
}
func (PodStatusContainerFieldPathBuilder) Terminated() Pod_Status_ContainerPathSelectorTerminated {
	return Pod_Status_ContainerPathSelectorTerminated{}
}

type Pod_Status_ContainerPathSelectorName struct{}

func (Pod_Status_ContainerPathSelectorName) FieldPath() *PodStatusContainer_FieldTerminalPath {
	return &PodStatusContainer_FieldTerminalPath{selector: PodStatusContainer_FieldPathSelectorName}
}

func (s Pod_Status_ContainerPathSelectorName) WithValue(value string) *PodStatusContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldTerminalPathValue)
}

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

type Pod_Status_ContainerPathSelectorState struct{}

func (Pod_Status_ContainerPathSelectorState) FieldPath() *PodStatusContainer_FieldTerminalPath {
	return &PodStatusContainer_FieldTerminalPath{selector: PodStatusContainer_FieldPathSelectorState}
}

func (s Pod_Status_ContainerPathSelectorState) WithValue(value Pod_Status_Container_State) *PodStatusContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldTerminalPathValue)
}

func (s Pod_Status_ContainerPathSelectorState) WithArrayOfValues(values []Pod_Status_Container_State) *PodStatusContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatusContainer_FieldTerminalPathArrayOfValues)
}

type Pod_Status_ContainerPathSelectorWaiting struct{}

func (Pod_Status_ContainerPathSelectorWaiting) FieldPath() *PodStatusContainer_FieldTerminalPath {
	return &PodStatusContainer_FieldTerminalPath{selector: PodStatusContainer_FieldPathSelectorWaiting}
}

func (s Pod_Status_ContainerPathSelectorWaiting) WithValue(value *Pod_Status_Container_StateWaiting) *PodStatusContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldTerminalPathValue)
}

func (s Pod_Status_ContainerPathSelectorWaiting) WithArrayOfValues(values []*Pod_Status_Container_StateWaiting) *PodStatusContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatusContainer_FieldTerminalPathArrayOfValues)
}

func (Pod_Status_ContainerPathSelectorWaiting) WithSubPath(subPath PodStatusContainerStateWaiting_FieldPath) *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{selector: PodStatusContainer_FieldPathSelectorWaiting, subPath: subPath}
}

func (s Pod_Status_ContainerPathSelectorWaiting) WithSubValue(subPathValue PodStatusContainerStateWaiting_FieldPathValue) *PodStatusContainer_FieldSubPathValue {
	return &PodStatusContainer_FieldSubPathValue{PodStatusContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Pod_Status_ContainerPathSelectorWaiting) WithSubArrayOfValues(subPathArrayOfValues PodStatusContainerStateWaiting_FieldPathArrayOfValues) *PodStatusContainer_FieldSubPathArrayOfValues {
	return &PodStatusContainer_FieldSubPathArrayOfValues{PodStatusContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Pod_Status_ContainerPathSelectorWaiting) WithSubArrayItemValue(subPathArrayItemValue PodStatusContainerStateWaiting_FieldPathArrayItemValue) *PodStatusContainer_FieldSubPathArrayItemValue {
	return &PodStatusContainer_FieldSubPathArrayItemValue{PodStatusContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Pod_Status_ContainerPathSelectorWaiting) Reason() Pod_Status_ContainerPathSelectorWaitingReason {
	return Pod_Status_ContainerPathSelectorWaitingReason{}
}

func (Pod_Status_ContainerPathSelectorWaiting) Message() Pod_Status_ContainerPathSelectorWaitingMessage {
	return Pod_Status_ContainerPathSelectorWaitingMessage{}
}

type Pod_Status_ContainerPathSelectorWaitingReason struct{}

func (Pod_Status_ContainerPathSelectorWaitingReason) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorWaiting,
		subPath:  NewPodStatusContainerStateWaitingFieldPathBuilder().Reason().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorWaitingReason) WithValue(value string) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorWaitingMessage struct{}

func (Pod_Status_ContainerPathSelectorWaitingMessage) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorWaiting,
		subPath:  NewPodStatusContainerStateWaitingFieldPathBuilder().Message().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorWaitingMessage) WithValue(value string) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorRunning struct{}

func (Pod_Status_ContainerPathSelectorRunning) FieldPath() *PodStatusContainer_FieldTerminalPath {
	return &PodStatusContainer_FieldTerminalPath{selector: PodStatusContainer_FieldPathSelectorRunning}
}

func (s Pod_Status_ContainerPathSelectorRunning) WithValue(value *Pod_Status_Container_StateRunning) *PodStatusContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldTerminalPathValue)
}

func (s Pod_Status_ContainerPathSelectorRunning) WithArrayOfValues(values []*Pod_Status_Container_StateRunning) *PodStatusContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatusContainer_FieldTerminalPathArrayOfValues)
}

func (Pod_Status_ContainerPathSelectorRunning) WithSubPath(subPath PodStatusContainerStateRunning_FieldPath) *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{selector: PodStatusContainer_FieldPathSelectorRunning, subPath: subPath}
}

func (s Pod_Status_ContainerPathSelectorRunning) WithSubValue(subPathValue PodStatusContainerStateRunning_FieldPathValue) *PodStatusContainer_FieldSubPathValue {
	return &PodStatusContainer_FieldSubPathValue{PodStatusContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Pod_Status_ContainerPathSelectorRunning) WithSubArrayOfValues(subPathArrayOfValues PodStatusContainerStateRunning_FieldPathArrayOfValues) *PodStatusContainer_FieldSubPathArrayOfValues {
	return &PodStatusContainer_FieldSubPathArrayOfValues{PodStatusContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Pod_Status_ContainerPathSelectorRunning) WithSubArrayItemValue(subPathArrayItemValue PodStatusContainerStateRunning_FieldPathArrayItemValue) *PodStatusContainer_FieldSubPathArrayItemValue {
	return &PodStatusContainer_FieldSubPathArrayItemValue{PodStatusContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Pod_Status_ContainerPathSelectorRunning) StartedAt() Pod_Status_ContainerPathSelectorRunningStartedAt {
	return Pod_Status_ContainerPathSelectorRunningStartedAt{}
}

type Pod_Status_ContainerPathSelectorRunningStartedAt struct{}

func (Pod_Status_ContainerPathSelectorRunningStartedAt) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorRunning,
		subPath:  NewPodStatusContainerStateRunningFieldPathBuilder().StartedAt().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorRunningStartedAt) WithValue(value *timestamppb.Timestamp) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminated struct{}

func (Pod_Status_ContainerPathSelectorTerminated) FieldPath() *PodStatusContainer_FieldTerminalPath {
	return &PodStatusContainer_FieldTerminalPath{selector: PodStatusContainer_FieldPathSelectorTerminated}
}

func (s Pod_Status_ContainerPathSelectorTerminated) WithValue(value *Pod_Status_Container_StateTerminated) *PodStatusContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldTerminalPathValue)
}

func (s Pod_Status_ContainerPathSelectorTerminated) WithArrayOfValues(values []*Pod_Status_Container_StateTerminated) *PodStatusContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodStatusContainer_FieldTerminalPathArrayOfValues)
}

func (Pod_Status_ContainerPathSelectorTerminated) WithSubPath(subPath PodStatusContainerStateTerminated_FieldPath) *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{selector: PodStatusContainer_FieldPathSelectorTerminated, subPath: subPath}
}

func (s Pod_Status_ContainerPathSelectorTerminated) WithSubValue(subPathValue PodStatusContainerStateTerminated_FieldPathValue) *PodStatusContainer_FieldSubPathValue {
	return &PodStatusContainer_FieldSubPathValue{PodStatusContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s Pod_Status_ContainerPathSelectorTerminated) WithSubArrayOfValues(subPathArrayOfValues PodStatusContainerStateTerminated_FieldPathArrayOfValues) *PodStatusContainer_FieldSubPathArrayOfValues {
	return &PodStatusContainer_FieldSubPathArrayOfValues{PodStatusContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s Pod_Status_ContainerPathSelectorTerminated) WithSubArrayItemValue(subPathArrayItemValue PodStatusContainerStateTerminated_FieldPathArrayItemValue) *PodStatusContainer_FieldSubPathArrayItemValue {
	return &PodStatusContainer_FieldSubPathArrayItemValue{PodStatusContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (Pod_Status_ContainerPathSelectorTerminated) ExitCode() Pod_Status_ContainerPathSelectorTerminatedExitCode {
	return Pod_Status_ContainerPathSelectorTerminatedExitCode{}
}

func (Pod_Status_ContainerPathSelectorTerminated) Signal() Pod_Status_ContainerPathSelectorTerminatedSignal {
	return Pod_Status_ContainerPathSelectorTerminatedSignal{}
}

func (Pod_Status_ContainerPathSelectorTerminated) Reason() Pod_Status_ContainerPathSelectorTerminatedReason {
	return Pod_Status_ContainerPathSelectorTerminatedReason{}
}

func (Pod_Status_ContainerPathSelectorTerminated) Message() Pod_Status_ContainerPathSelectorTerminatedMessage {
	return Pod_Status_ContainerPathSelectorTerminatedMessage{}
}

func (Pod_Status_ContainerPathSelectorTerminated) StartedAt() Pod_Status_ContainerPathSelectorTerminatedStartedAt {
	return Pod_Status_ContainerPathSelectorTerminatedStartedAt{}
}

func (Pod_Status_ContainerPathSelectorTerminated) FinishedAt() Pod_Status_ContainerPathSelectorTerminatedFinishedAt {
	return Pod_Status_ContainerPathSelectorTerminatedFinishedAt{}
}

func (Pod_Status_ContainerPathSelectorTerminated) ContainerId() Pod_Status_ContainerPathSelectorTerminatedContainerId {
	return Pod_Status_ContainerPathSelectorTerminatedContainerId{}
}

type Pod_Status_ContainerPathSelectorTerminatedExitCode struct{}

func (Pod_Status_ContainerPathSelectorTerminatedExitCode) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().ExitCode().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedExitCode) WithValue(value int32) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminatedSignal struct{}

func (Pod_Status_ContainerPathSelectorTerminatedSignal) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().Signal().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedSignal) WithValue(value int32) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminatedReason struct{}

func (Pod_Status_ContainerPathSelectorTerminatedReason) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().Reason().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedReason) WithValue(value string) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminatedMessage struct{}

func (Pod_Status_ContainerPathSelectorTerminatedMessage) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().Message().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedMessage) WithValue(value string) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminatedStartedAt struct{}

func (Pod_Status_ContainerPathSelectorTerminatedStartedAt) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().StartedAt().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedStartedAt) WithValue(value *timestamppb.Timestamp) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminatedFinishedAt struct{}

func (Pod_Status_ContainerPathSelectorTerminatedFinishedAt) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().FinishedAt().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedFinishedAt) WithValue(value *timestamppb.Timestamp) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type Pod_Status_ContainerPathSelectorTerminatedContainerId struct{}

func (Pod_Status_ContainerPathSelectorTerminatedContainerId) FieldPath() *PodStatusContainer_FieldSubPath {
	return &PodStatusContainer_FieldSubPath{
		selector: PodStatusContainer_FieldPathSelectorTerminated,
		subPath:  NewPodStatusContainerStateTerminatedFieldPathBuilder().ContainerId().FieldPath(),
	}
}

func (s Pod_Status_ContainerPathSelectorTerminatedContainerId) WithValue(value string) *PodStatusContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainer_FieldSubPathValue)
}

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

type PodStatusContainerStateWaitingFieldPathBuilder struct{}

func NewPodStatusContainerStateWaitingFieldPathBuilder() PodStatusContainerStateWaitingFieldPathBuilder {
	return PodStatusContainerStateWaitingFieldPathBuilder{}
}
func (PodStatusContainerStateWaitingFieldPathBuilder) Reason() Pod_Status_Container_StateWaitingPathSelectorReason {
	return Pod_Status_Container_StateWaitingPathSelectorReason{}
}
func (PodStatusContainerStateWaitingFieldPathBuilder) Message() Pod_Status_Container_StateWaitingPathSelectorMessage {
	return Pod_Status_Container_StateWaitingPathSelectorMessage{}
}

type Pod_Status_Container_StateWaitingPathSelectorReason struct{}

func (Pod_Status_Container_StateWaitingPathSelectorReason) FieldPath() *PodStatusContainerStateWaiting_FieldTerminalPath {
	return &PodStatusContainerStateWaiting_FieldTerminalPath{selector: PodStatusContainerStateWaiting_FieldPathSelectorReason}
}

func (s Pod_Status_Container_StateWaitingPathSelectorReason) WithValue(value string) *PodStatusContainerStateWaiting_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateWaiting_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateWaitingPathSelectorMessage struct{}

func (Pod_Status_Container_StateWaitingPathSelectorMessage) FieldPath() *PodStatusContainerStateWaiting_FieldTerminalPath {
	return &PodStatusContainerStateWaiting_FieldTerminalPath{selector: PodStatusContainerStateWaiting_FieldPathSelectorMessage}
}

func (s Pod_Status_Container_StateWaitingPathSelectorMessage) WithValue(value string) *PodStatusContainerStateWaiting_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateWaiting_FieldTerminalPathValue)
}

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

type PodStatusContainerStateRunningFieldPathBuilder struct{}

func NewPodStatusContainerStateRunningFieldPathBuilder() PodStatusContainerStateRunningFieldPathBuilder {
	return PodStatusContainerStateRunningFieldPathBuilder{}
}
func (PodStatusContainerStateRunningFieldPathBuilder) StartedAt() Pod_Status_Container_StateRunningPathSelectorStartedAt {
	return Pod_Status_Container_StateRunningPathSelectorStartedAt{}
}

type Pod_Status_Container_StateRunningPathSelectorStartedAt struct{}

func (Pod_Status_Container_StateRunningPathSelectorStartedAt) FieldPath() *PodStatusContainerStateRunning_FieldTerminalPath {
	return &PodStatusContainerStateRunning_FieldTerminalPath{selector: PodStatusContainerStateRunning_FieldPathSelectorStartedAt}
}

func (s Pod_Status_Container_StateRunningPathSelectorStartedAt) WithValue(value *timestamppb.Timestamp) *PodStatusContainerStateRunning_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateRunning_FieldTerminalPathValue)
}

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

type PodStatusContainerStateTerminatedFieldPathBuilder struct{}

func NewPodStatusContainerStateTerminatedFieldPathBuilder() PodStatusContainerStateTerminatedFieldPathBuilder {
	return PodStatusContainerStateTerminatedFieldPathBuilder{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) ExitCode() Pod_Status_Container_StateTerminatedPathSelectorExitCode {
	return Pod_Status_Container_StateTerminatedPathSelectorExitCode{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) Signal() Pod_Status_Container_StateTerminatedPathSelectorSignal {
	return Pod_Status_Container_StateTerminatedPathSelectorSignal{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) Reason() Pod_Status_Container_StateTerminatedPathSelectorReason {
	return Pod_Status_Container_StateTerminatedPathSelectorReason{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) Message() Pod_Status_Container_StateTerminatedPathSelectorMessage {
	return Pod_Status_Container_StateTerminatedPathSelectorMessage{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) StartedAt() Pod_Status_Container_StateTerminatedPathSelectorStartedAt {
	return Pod_Status_Container_StateTerminatedPathSelectorStartedAt{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) FinishedAt() Pod_Status_Container_StateTerminatedPathSelectorFinishedAt {
	return Pod_Status_Container_StateTerminatedPathSelectorFinishedAt{}
}
func (PodStatusContainerStateTerminatedFieldPathBuilder) ContainerId() Pod_Status_Container_StateTerminatedPathSelectorContainerId {
	return Pod_Status_Container_StateTerminatedPathSelectorContainerId{}
}

type Pod_Status_Container_StateTerminatedPathSelectorExitCode struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorExitCode) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorExitCode}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorExitCode) WithValue(value int32) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateTerminatedPathSelectorSignal struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorSignal) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorSignal}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorSignal) WithValue(value int32) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateTerminatedPathSelectorReason struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorReason) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorReason}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorReason) WithValue(value string) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateTerminatedPathSelectorMessage struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorMessage) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorMessage}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorMessage) WithValue(value string) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateTerminatedPathSelectorStartedAt struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorStartedAt) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorStartedAt}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorStartedAt) WithValue(value *timestamppb.Timestamp) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateTerminatedPathSelectorFinishedAt struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorFinishedAt) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorFinishedAt}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorFinishedAt) WithValue(value *timestamppb.Timestamp) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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

type Pod_Status_Container_StateTerminatedPathSelectorContainerId struct{}

func (Pod_Status_Container_StateTerminatedPathSelectorContainerId) FieldPath() *PodStatusContainerStateTerminated_FieldTerminalPath {
	return &PodStatusContainerStateTerminated_FieldTerminalPath{selector: PodStatusContainerStateTerminated_FieldPathSelectorContainerId}
}

func (s Pod_Status_Container_StateTerminatedPathSelectorContainerId) WithValue(value string) *PodStatusContainerStateTerminated_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodStatusContainerStateTerminated_FieldTerminalPathValue)
}

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