common.pb.fieldpathbuilder.go

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

package common

// proto imports
import (
	devices_device "github.com/cloudwan/edgelq-sdk/devices/resources/v1/device"
	devices_project "github.com/cloudwan/edgelq-sdk/devices/resources/v1/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1/service_account"
	logging_bucket "github.com/cloudwan/edgelq-sdk/logging/resources/v1/bucket"
	logging_common "github.com/cloudwan/edgelq-sdk/logging/resources/v1/common"
	logging_log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log_descriptor"
	monitoring_bucket "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/bucket"
	monitoring_project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	secrets_project "github.com/cloudwan/edgelq-sdk/secrets/resources/v1/project"
	secrets_secret "github.com/cloudwan/edgelq-sdk/secrets/resources/v1/secret"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	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 (
	_ = &devices_device.Device{}
	_ = &devices_project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &logging_bucket.Bucket{}
	_ = &logging_common.LabelDescriptor{}
	_ = &logging_log_descriptor.LogDescriptor{}
	_ = &monitoring_bucket.Bucket{}
	_ = &monitoring_project.Project{}
	_ = &secrets_project.Project{}
	_ = &secrets_secret.Secret{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type PodSpecFieldPathBuilder struct{}

func NewPodSpecFieldPathBuilder() PodSpecFieldPathBuilder {
	return PodSpecFieldPathBuilder{}
}
func (PodSpecFieldPathBuilder) Node() PodSpecPathSelectorNode {
	return PodSpecPathSelectorNode{}
}
func (PodSpecFieldPathBuilder) Containers() PodSpecPathSelectorContainers {
	return PodSpecPathSelectorContainers{}
}
func (PodSpecFieldPathBuilder) HostNetwork() PodSpecPathSelectorHostNetwork {
	return PodSpecPathSelectorHostNetwork{}
}
func (PodSpecFieldPathBuilder) RestartPolicy() PodSpecPathSelectorRestartPolicy {
	return PodSpecPathSelectorRestartPolicy{}
}
func (PodSpecFieldPathBuilder) ImagePullSecrets() PodSpecPathSelectorImagePullSecrets {
	return PodSpecPathSelectorImagePullSecrets{}
}
func (PodSpecFieldPathBuilder) Volumes() PodSpecPathSelectorVolumes {
	return PodSpecPathSelectorVolumes{}
}
func (PodSpecFieldPathBuilder) Compose() PodSpecPathSelectorCompose {
	return PodSpecPathSelectorCompose{}
}
func (PodSpecFieldPathBuilder) HostVolumeMounts() PodSpecPathSelectorHostVolumeMounts {
	return PodSpecPathSelectorHostVolumeMounts{}
}

type PodSpecPathSelectorNode struct{}

func (PodSpecPathSelectorNode) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorNode}
}

func (s PodSpecPathSelectorNode) WithValue(value *devices_device.Reference) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

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

type PodSpecPathSelectorContainers struct{}

func (PodSpecPathSelectorContainers) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorContainers}
}

func (s PodSpecPathSelectorContainers) WithValue(value []*PodSpec_Container) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

func (s PodSpecPathSelectorContainers) WithArrayOfValues(values [][]*PodSpec_Container) *PodSpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldTerminalPathArrayOfValues)
}

func (s PodSpecPathSelectorContainers) WithItemValue(value *PodSpec_Container) *PodSpec_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldTerminalPathArrayItemValue)
}
func (PodSpecPathSelectorContainers) WithSubPath(subPath PodSpecContainer_FieldPath) *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{selector: PodSpec_FieldPathSelectorContainers, subPath: subPath}
}

func (s PodSpecPathSelectorContainers) WithSubValue(subPathValue PodSpecContainer_FieldPathValue) *PodSpec_FieldSubPathValue {
	return &PodSpec_FieldSubPathValue{PodSpec_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpecPathSelectorContainers) WithSubArrayOfValues(subPathArrayOfValues PodSpecContainer_FieldPathArrayOfValues) *PodSpec_FieldSubPathArrayOfValues {
	return &PodSpec_FieldSubPathArrayOfValues{PodSpec_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpecPathSelectorContainers) WithSubArrayItemValue(subPathArrayItemValue PodSpecContainer_FieldPathArrayItemValue) *PodSpec_FieldSubPathArrayItemValue {
	return &PodSpec_FieldSubPathArrayItemValue{PodSpec_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpecPathSelectorContainers) Args() PodSpecPathSelectorContainersArgs {
	return PodSpecPathSelectorContainersArgs{}
}

func (PodSpecPathSelectorContainers) Command() PodSpecPathSelectorContainersCommand {
	return PodSpecPathSelectorContainersCommand{}
}

func (PodSpecPathSelectorContainers) Env() PodSpecPathSelectorContainersEnv {
	return PodSpecPathSelectorContainersEnv{}
}

func (PodSpecPathSelectorContainers) Image() PodSpecPathSelectorContainersImage {
	return PodSpecPathSelectorContainersImage{}
}

func (PodSpecPathSelectorContainers) ImagePullPolicy() PodSpecPathSelectorContainersImagePullPolicy {
	return PodSpecPathSelectorContainersImagePullPolicy{}
}

func (PodSpecPathSelectorContainers) Name() PodSpecPathSelectorContainersName {
	return PodSpecPathSelectorContainersName{}
}

func (PodSpecPathSelectorContainers) Resources() PodSpecPathSelectorContainersResources {
	return PodSpecPathSelectorContainersResources{}
}

func (PodSpecPathSelectorContainers) SecurityContext() PodSpecPathSelectorContainersSecurityContext {
	return PodSpecPathSelectorContainersSecurityContext{}
}

func (PodSpecPathSelectorContainers) VolumeMounts() PodSpecPathSelectorContainersVolumeMounts {
	return PodSpecPathSelectorContainersVolumeMounts{}
}

func (PodSpecPathSelectorContainers) EnvFrom() PodSpecPathSelectorContainersEnvFrom {
	return PodSpecPathSelectorContainersEnvFrom{}
}

type PodSpecPathSelectorContainersArgs struct{}

func (PodSpecPathSelectorContainersArgs) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Args().FieldPath(),
	}
}

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

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

func (s PodSpecPathSelectorContainersArgs) WithItemValue(value string) *PodSpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldSubPathArrayItemValue)
}

type PodSpecPathSelectorContainersCommand struct{}

func (PodSpecPathSelectorContainersCommand) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Command().FieldPath(),
	}
}

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

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

func (s PodSpecPathSelectorContainersCommand) WithItemValue(value string) *PodSpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldSubPathArrayItemValue)
}

type PodSpecPathSelectorContainersEnv struct{}

func (PodSpecPathSelectorContainersEnv) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnv) WithValue(value []*EnvVar) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnv) WithArrayOfValues(values [][]*EnvVar) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (s PodSpecPathSelectorContainersEnv) WithItemValue(value *EnvVar) *PodSpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldSubPathArrayItemValue)
}

func (PodSpecPathSelectorContainersEnv) Name() PodSpecPathSelectorContainersEnvName {
	return PodSpecPathSelectorContainersEnvName{}
}

func (PodSpecPathSelectorContainersEnv) Value() PodSpecPathSelectorContainersEnvValue {
	return PodSpecPathSelectorContainersEnvValue{}
}

func (PodSpecPathSelectorContainersEnv) ValueFrom() PodSpecPathSelectorContainersEnvValueFrom {
	return PodSpecPathSelectorContainersEnvValueFrom{}
}

type PodSpecPathSelectorContainersEnvName struct{}

func (PodSpecPathSelectorContainersEnvName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValue struct{}

func (PodSpecPathSelectorContainersEnvValue) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().Value().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValue) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValueFrom struct{}

func (PodSpecPathSelectorContainersEnvValueFrom) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFrom) WithValue(value *EnvVarSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnvValueFrom) WithArrayOfValues(values []*EnvVarSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersEnvValueFrom) ConfigMapKeyRef() PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef {
	return PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef{}
}

func (PodSpecPathSelectorContainersEnvValueFrom) SecretKeyRef() PodSpecPathSelectorContainersEnvValueFromSecretKeyRef {
	return PodSpecPathSelectorContainersEnvValueFromSecretKeyRef{}
}

type PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef struct{}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().ConfigMapKeyRef().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef) WithValue(value *ConfigMapKeySelector) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef) WithArrayOfValues(values []*ConfigMapKeySelector) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef) Name() PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefName {
	return PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefName{}
}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef) Key() PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefKey {
	return PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefKey{}
}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRef) Optional() PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefOptional {
	return PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefOptional{}
}

type PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefName struct{}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().ConfigMapKeyRef().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefKey struct{}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefKey) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().ConfigMapKeyRef().Key().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefKey) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefOptional struct{}

func (PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefOptional) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().ConfigMapKeyRef().Optional().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromConfigMapKeyRefOptional) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValueFromSecretKeyRef struct{}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRef) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().SecretKeyRef().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromSecretKeyRef) WithValue(value *SecretKeySelector) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnvValueFromSecretKeyRef) WithArrayOfValues(values []*SecretKeySelector) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRef) Name() PodSpecPathSelectorContainersEnvValueFromSecretKeyRefName {
	return PodSpecPathSelectorContainersEnvValueFromSecretKeyRefName{}
}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRef) Key() PodSpecPathSelectorContainersEnvValueFromSecretKeyRefKey {
	return PodSpecPathSelectorContainersEnvValueFromSecretKeyRefKey{}
}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRef) Optional() PodSpecPathSelectorContainersEnvValueFromSecretKeyRefOptional {
	return PodSpecPathSelectorContainersEnvValueFromSecretKeyRefOptional{}
}

type PodSpecPathSelectorContainersEnvValueFromSecretKeyRefName struct{}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRefName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().SecretKeyRef().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromSecretKeyRefName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValueFromSecretKeyRefKey struct{}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRefKey) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().SecretKeyRef().Key().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromSecretKeyRefKey) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvValueFromSecretKeyRefOptional struct{}

func (PodSpecPathSelectorContainersEnvValueFromSecretKeyRefOptional) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Env().ValueFrom().SecretKeyRef().Optional().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvValueFromSecretKeyRefOptional) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersImage struct{}

func (PodSpecPathSelectorContainersImage) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Image().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersImage) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersImagePullPolicy struct{}

func (PodSpecPathSelectorContainersImagePullPolicy) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().ImagePullPolicy().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersImagePullPolicy) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersName struct{}

func (PodSpecPathSelectorContainersName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersResources struct{}

func (PodSpecPathSelectorContainersResources) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Resources().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersResources) WithValue(value *PodSpec_Container_ResourceRequirements) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersResources) WithArrayOfValues(values []*PodSpec_Container_ResourceRequirements) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersResources) Limits() PodSpecPathSelectorContainersResourcesLimits {
	return PodSpecPathSelectorContainersResourcesLimits{}
}

func (PodSpecPathSelectorContainersResources) Requests() PodSpecPathSelectorContainersResourcesRequests {
	return PodSpecPathSelectorContainersResourcesRequests{}
}

type PodSpecPathSelectorContainersResourcesLimits struct{}

func (PodSpecPathSelectorContainersResourcesLimits) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Resources().Limits().FieldPath(),
	}
}

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

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

func (PodSpecPathSelectorContainersResourcesLimits) WithKey(key string) PodSpecMapPathSelectorContainersResourcesLimits {
	return PodSpecMapPathSelectorContainersResourcesLimits{key: key}
}

type PodSpecMapPathSelectorContainersResourcesLimits struct {
	key string
}

func (s PodSpecMapPathSelectorContainersResourcesLimits) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Resources().Limits().WithKey(s.key).FieldPath(),
	}
}

func (s PodSpecMapPathSelectorContainersResourcesLimits) WithValue(value int64) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersResourcesRequests struct{}

func (PodSpecPathSelectorContainersResourcesRequests) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Resources().Requests().FieldPath(),
	}
}

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

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

func (PodSpecPathSelectorContainersResourcesRequests) WithKey(key string) PodSpecMapPathSelectorContainersResourcesRequests {
	return PodSpecMapPathSelectorContainersResourcesRequests{key: key}
}

type PodSpecMapPathSelectorContainersResourcesRequests struct {
	key string
}

func (s PodSpecMapPathSelectorContainersResourcesRequests) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().Resources().Requests().WithKey(s.key).FieldPath(),
	}
}

func (s PodSpecMapPathSelectorContainersResourcesRequests) WithValue(value int64) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersSecurityContext struct{}

func (PodSpecPathSelectorContainersSecurityContext) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().SecurityContext().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersSecurityContext) WithValue(value *SecurityContext) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersSecurityContext) WithArrayOfValues(values []*SecurityContext) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersSecurityContext) Privileged() PodSpecPathSelectorContainersSecurityContextPrivileged {
	return PodSpecPathSelectorContainersSecurityContextPrivileged{}
}

type PodSpecPathSelectorContainersSecurityContextPrivileged struct{}

func (PodSpecPathSelectorContainersSecurityContextPrivileged) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().SecurityContext().Privileged().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersSecurityContextPrivileged) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersVolumeMounts struct{}

func (PodSpecPathSelectorContainersVolumeMounts) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().VolumeMounts().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersVolumeMounts) WithValue(value []*VolumeMount) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersVolumeMounts) WithArrayOfValues(values [][]*VolumeMount) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (s PodSpecPathSelectorContainersVolumeMounts) WithItemValue(value *VolumeMount) *PodSpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldSubPathArrayItemValue)
}

func (PodSpecPathSelectorContainersVolumeMounts) Name() PodSpecPathSelectorContainersVolumeMountsName {
	return PodSpecPathSelectorContainersVolumeMountsName{}
}

func (PodSpecPathSelectorContainersVolumeMounts) ReadOnly() PodSpecPathSelectorContainersVolumeMountsReadOnly {
	return PodSpecPathSelectorContainersVolumeMountsReadOnly{}
}

func (PodSpecPathSelectorContainersVolumeMounts) MountPath() PodSpecPathSelectorContainersVolumeMountsMountPath {
	return PodSpecPathSelectorContainersVolumeMountsMountPath{}
}

func (PodSpecPathSelectorContainersVolumeMounts) SubPath() PodSpecPathSelectorContainersVolumeMountsSubPath {
	return PodSpecPathSelectorContainersVolumeMountsSubPath{}
}

type PodSpecPathSelectorContainersVolumeMountsName struct{}

func (PodSpecPathSelectorContainersVolumeMountsName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().VolumeMounts().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersVolumeMountsName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersVolumeMountsReadOnly struct{}

func (PodSpecPathSelectorContainersVolumeMountsReadOnly) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().VolumeMounts().ReadOnly().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersVolumeMountsReadOnly) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersVolumeMountsMountPath struct{}

func (PodSpecPathSelectorContainersVolumeMountsMountPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().VolumeMounts().MountPath().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersVolumeMountsMountPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersVolumeMountsSubPath struct{}

func (PodSpecPathSelectorContainersVolumeMountsSubPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().VolumeMounts().SubPath().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersVolumeMountsSubPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvFrom struct{}

func (PodSpecPathSelectorContainersEnvFrom) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFrom) WithValue(value *EnvFromSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnvFrom) WithArrayOfValues(values []*EnvFromSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersEnvFrom) Prefix() PodSpecPathSelectorContainersEnvFromPrefix {
	return PodSpecPathSelectorContainersEnvFromPrefix{}
}

func (PodSpecPathSelectorContainersEnvFrom) ConfigMapRef() PodSpecPathSelectorContainersEnvFromConfigMapRef {
	return PodSpecPathSelectorContainersEnvFromConfigMapRef{}
}

func (PodSpecPathSelectorContainersEnvFrom) SecretRef() PodSpecPathSelectorContainersEnvFromSecretRef {
	return PodSpecPathSelectorContainersEnvFromSecretRef{}
}

type PodSpecPathSelectorContainersEnvFromPrefix struct{}

func (PodSpecPathSelectorContainersEnvFromPrefix) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().Prefix().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromPrefix) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvFromConfigMapRef struct{}

func (PodSpecPathSelectorContainersEnvFromConfigMapRef) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().ConfigMapRef().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromConfigMapRef) WithValue(value *ConfigMapEnvSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnvFromConfigMapRef) WithArrayOfValues(values []*ConfigMapEnvSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersEnvFromConfigMapRef) Name() PodSpecPathSelectorContainersEnvFromConfigMapRefName {
	return PodSpecPathSelectorContainersEnvFromConfigMapRefName{}
}

func (PodSpecPathSelectorContainersEnvFromConfigMapRef) Optional() PodSpecPathSelectorContainersEnvFromConfigMapRefOptional {
	return PodSpecPathSelectorContainersEnvFromConfigMapRefOptional{}
}

type PodSpecPathSelectorContainersEnvFromConfigMapRefName struct{}

func (PodSpecPathSelectorContainersEnvFromConfigMapRefName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().ConfigMapRef().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromConfigMapRefName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvFromConfigMapRefOptional struct{}

func (PodSpecPathSelectorContainersEnvFromConfigMapRefOptional) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().ConfigMapRef().Optional().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromConfigMapRefOptional) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvFromSecretRef struct{}

func (PodSpecPathSelectorContainersEnvFromSecretRef) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().SecretRef().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromSecretRef) WithValue(value *SecretEnvSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorContainersEnvFromSecretRef) WithArrayOfValues(values []*SecretEnvSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorContainersEnvFromSecretRef) Name() PodSpecPathSelectorContainersEnvFromSecretRefName {
	return PodSpecPathSelectorContainersEnvFromSecretRefName{}
}

func (PodSpecPathSelectorContainersEnvFromSecretRef) Optional() PodSpecPathSelectorContainersEnvFromSecretRefOptional {
	return PodSpecPathSelectorContainersEnvFromSecretRefOptional{}
}

type PodSpecPathSelectorContainersEnvFromSecretRefName struct{}

func (PodSpecPathSelectorContainersEnvFromSecretRefName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().SecretRef().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromSecretRefName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorContainersEnvFromSecretRefOptional struct{}

func (PodSpecPathSelectorContainersEnvFromSecretRefOptional) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorContainers,
		subPath:  NewPodSpecContainerFieldPathBuilder().EnvFrom().SecretRef().Optional().FieldPath(),
	}
}

func (s PodSpecPathSelectorContainersEnvFromSecretRefOptional) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorHostNetwork struct{}

func (PodSpecPathSelectorHostNetwork) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorHostNetwork}
}

func (s PodSpecPathSelectorHostNetwork) WithValue(value bool) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

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

type PodSpecPathSelectorRestartPolicy struct{}

func (PodSpecPathSelectorRestartPolicy) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorRestartPolicy}
}

func (s PodSpecPathSelectorRestartPolicy) WithValue(value PodSpec_RestartPolicy) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

func (s PodSpecPathSelectorRestartPolicy) WithArrayOfValues(values []PodSpec_RestartPolicy) *PodSpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldTerminalPathArrayOfValues)
}

type PodSpecPathSelectorImagePullSecrets struct{}

func (PodSpecPathSelectorImagePullSecrets) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorImagePullSecrets}
}

func (s PodSpecPathSelectorImagePullSecrets) WithValue(value []*LocalObjectReferenceSecret) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

func (s PodSpecPathSelectorImagePullSecrets) WithArrayOfValues(values [][]*LocalObjectReferenceSecret) *PodSpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldTerminalPathArrayOfValues)
}

func (s PodSpecPathSelectorImagePullSecrets) WithItemValue(value *LocalObjectReferenceSecret) *PodSpec_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldTerminalPathArrayItemValue)
}
func (PodSpecPathSelectorImagePullSecrets) WithSubPath(subPath LocalObjectReferenceSecret_FieldPath) *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{selector: PodSpec_FieldPathSelectorImagePullSecrets, subPath: subPath}
}

func (s PodSpecPathSelectorImagePullSecrets) WithSubValue(subPathValue LocalObjectReferenceSecret_FieldPathValue) *PodSpec_FieldSubPathValue {
	return &PodSpec_FieldSubPathValue{PodSpec_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpecPathSelectorImagePullSecrets) WithSubArrayOfValues(subPathArrayOfValues LocalObjectReferenceSecret_FieldPathArrayOfValues) *PodSpec_FieldSubPathArrayOfValues {
	return &PodSpec_FieldSubPathArrayOfValues{PodSpec_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpecPathSelectorImagePullSecrets) WithSubArrayItemValue(subPathArrayItemValue LocalObjectReferenceSecret_FieldPathArrayItemValue) *PodSpec_FieldSubPathArrayItemValue {
	return &PodSpec_FieldSubPathArrayItemValue{PodSpec_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpecPathSelectorImagePullSecrets) Name() PodSpecPathSelectorImagePullSecretsName {
	return PodSpecPathSelectorImagePullSecretsName{}
}

type PodSpecPathSelectorImagePullSecretsName struct{}

func (PodSpecPathSelectorImagePullSecretsName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorImagePullSecrets,
		subPath:  NewLocalObjectReferenceSecretFieldPathBuilder().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorImagePullSecretsName) WithValue(value *secrets_secret.Reference) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumes struct{}

func (PodSpecPathSelectorVolumes) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorVolumes}
}

func (s PodSpecPathSelectorVolumes) WithValue(value []*Volume) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

func (s PodSpecPathSelectorVolumes) WithArrayOfValues(values [][]*Volume) *PodSpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldTerminalPathArrayOfValues)
}

func (s PodSpecPathSelectorVolumes) WithItemValue(value *Volume) *PodSpec_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldTerminalPathArrayItemValue)
}
func (PodSpecPathSelectorVolumes) WithSubPath(subPath Volume_FieldPath) *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{selector: PodSpec_FieldPathSelectorVolumes, subPath: subPath}
}

func (s PodSpecPathSelectorVolumes) WithSubValue(subPathValue Volume_FieldPathValue) *PodSpec_FieldSubPathValue {
	return &PodSpec_FieldSubPathValue{PodSpec_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpecPathSelectorVolumes) WithSubArrayOfValues(subPathArrayOfValues Volume_FieldPathArrayOfValues) *PodSpec_FieldSubPathArrayOfValues {
	return &PodSpec_FieldSubPathArrayOfValues{PodSpec_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpecPathSelectorVolumes) WithSubArrayItemValue(subPathArrayItemValue Volume_FieldPathArrayItemValue) *PodSpec_FieldSubPathArrayItemValue {
	return &PodSpec_FieldSubPathArrayItemValue{PodSpec_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpecPathSelectorVolumes) Name() PodSpecPathSelectorVolumesName {
	return PodSpecPathSelectorVolumesName{}
}

func (PodSpecPathSelectorVolumes) HostPath() PodSpecPathSelectorVolumesHostPath {
	return PodSpecPathSelectorVolumesHostPath{}
}

func (PodSpecPathSelectorVolumes) Secret() PodSpecPathSelectorVolumesSecret {
	return PodSpecPathSelectorVolumesSecret{}
}

func (PodSpecPathSelectorVolumes) ConfigMap() PodSpecPathSelectorVolumesConfigMap {
	return PodSpecPathSelectorVolumesConfigMap{}
}

type PodSpecPathSelectorVolumesName struct{}

func (PodSpecPathSelectorVolumesName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesHostPath struct{}

func (PodSpecPathSelectorVolumesHostPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().HostPath().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesHostPath) WithValue(value *HostPathVolumeSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorVolumesHostPath) WithArrayOfValues(values []*HostPathVolumeSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorVolumesHostPath) Path() PodSpecPathSelectorVolumesHostPathPath {
	return PodSpecPathSelectorVolumesHostPathPath{}
}

func (PodSpecPathSelectorVolumesHostPath) Type() PodSpecPathSelectorVolumesHostPathType {
	return PodSpecPathSelectorVolumesHostPathType{}
}

type PodSpecPathSelectorVolumesHostPathPath struct{}

func (PodSpecPathSelectorVolumesHostPathPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().HostPath().Path().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesHostPathPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesHostPathType struct{}

func (PodSpecPathSelectorVolumesHostPathType) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().HostPath().Type().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesHostPathType) WithValue(value HostPathVolumeSource_Type) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorVolumesHostPathType) WithArrayOfValues(values []HostPathVolumeSource_Type) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

type PodSpecPathSelectorVolumesSecret struct{}

func (PodSpecPathSelectorVolumesSecret) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecret) WithValue(value *SecretVolumeSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorVolumesSecret) WithArrayOfValues(values []*SecretVolumeSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorVolumesSecret) SecretName() PodSpecPathSelectorVolumesSecretSecretName {
	return PodSpecPathSelectorVolumesSecretSecretName{}
}

func (PodSpecPathSelectorVolumesSecret) Items() PodSpecPathSelectorVolumesSecretItems {
	return PodSpecPathSelectorVolumesSecretItems{}
}

func (PodSpecPathSelectorVolumesSecret) DefaultMode() PodSpecPathSelectorVolumesSecretDefaultMode {
	return PodSpecPathSelectorVolumesSecretDefaultMode{}
}

func (PodSpecPathSelectorVolumesSecret) Optional() PodSpecPathSelectorVolumesSecretOptional {
	return PodSpecPathSelectorVolumesSecretOptional{}
}

type PodSpecPathSelectorVolumesSecretSecretName struct{}

func (PodSpecPathSelectorVolumesSecretSecretName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().SecretName().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretSecretName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesSecretItems struct{}

func (PodSpecPathSelectorVolumesSecretItems) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().Items().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretItems) WithValue(value []*KeyToPath) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorVolumesSecretItems) WithArrayOfValues(values [][]*KeyToPath) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (s PodSpecPathSelectorVolumesSecretItems) WithItemValue(value *KeyToPath) *PodSpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldSubPathArrayItemValue)
}

func (PodSpecPathSelectorVolumesSecretItems) Key() PodSpecPathSelectorVolumesSecretItemsKey {
	return PodSpecPathSelectorVolumesSecretItemsKey{}
}

func (PodSpecPathSelectorVolumesSecretItems) Path() PodSpecPathSelectorVolumesSecretItemsPath {
	return PodSpecPathSelectorVolumesSecretItemsPath{}
}

func (PodSpecPathSelectorVolumesSecretItems) Mode() PodSpecPathSelectorVolumesSecretItemsMode {
	return PodSpecPathSelectorVolumesSecretItemsMode{}
}

type PodSpecPathSelectorVolumesSecretItemsKey struct{}

func (PodSpecPathSelectorVolumesSecretItemsKey) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().Items().Key().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretItemsKey) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesSecretItemsPath struct{}

func (PodSpecPathSelectorVolumesSecretItemsPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().Items().Path().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretItemsPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesSecretItemsMode struct{}

func (PodSpecPathSelectorVolumesSecretItemsMode) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().Items().Mode().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretItemsMode) WithValue(value int32) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesSecretDefaultMode struct{}

func (PodSpecPathSelectorVolumesSecretDefaultMode) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().DefaultMode().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretDefaultMode) WithValue(value int32) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesSecretOptional struct{}

func (PodSpecPathSelectorVolumesSecretOptional) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().Secret().Optional().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesSecretOptional) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesConfigMap struct{}

func (PodSpecPathSelectorVolumesConfigMap) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMap) WithValue(value *ConfigMapVolumeSource) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorVolumesConfigMap) WithArrayOfValues(values []*ConfigMapVolumeSource) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (PodSpecPathSelectorVolumesConfigMap) Name() PodSpecPathSelectorVolumesConfigMapName {
	return PodSpecPathSelectorVolumesConfigMapName{}
}

func (PodSpecPathSelectorVolumesConfigMap) Items() PodSpecPathSelectorVolumesConfigMapItems {
	return PodSpecPathSelectorVolumesConfigMapItems{}
}

func (PodSpecPathSelectorVolumesConfigMap) DefaultMode() PodSpecPathSelectorVolumesConfigMapDefaultMode {
	return PodSpecPathSelectorVolumesConfigMapDefaultMode{}
}

func (PodSpecPathSelectorVolumesConfigMap) Optional() PodSpecPathSelectorVolumesConfigMapOptional {
	return PodSpecPathSelectorVolumesConfigMapOptional{}
}

type PodSpecPathSelectorVolumesConfigMapName struct{}

func (PodSpecPathSelectorVolumesConfigMapName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesConfigMapItems struct{}

func (PodSpecPathSelectorVolumesConfigMapItems) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().Items().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapItems) WithValue(value []*KeyToPath) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

func (s PodSpecPathSelectorVolumesConfigMapItems) WithArrayOfValues(values [][]*KeyToPath) *PodSpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldSubPathArrayOfValues)
}

func (s PodSpecPathSelectorVolumesConfigMapItems) WithItemValue(value *KeyToPath) *PodSpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldSubPathArrayItemValue)
}

func (PodSpecPathSelectorVolumesConfigMapItems) Key() PodSpecPathSelectorVolumesConfigMapItemsKey {
	return PodSpecPathSelectorVolumesConfigMapItemsKey{}
}

func (PodSpecPathSelectorVolumesConfigMapItems) Path() PodSpecPathSelectorVolumesConfigMapItemsPath {
	return PodSpecPathSelectorVolumesConfigMapItemsPath{}
}

func (PodSpecPathSelectorVolumesConfigMapItems) Mode() PodSpecPathSelectorVolumesConfigMapItemsMode {
	return PodSpecPathSelectorVolumesConfigMapItemsMode{}
}

type PodSpecPathSelectorVolumesConfigMapItemsKey struct{}

func (PodSpecPathSelectorVolumesConfigMapItemsKey) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().Items().Key().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapItemsKey) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesConfigMapItemsPath struct{}

func (PodSpecPathSelectorVolumesConfigMapItemsPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().Items().Path().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapItemsPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesConfigMapItemsMode struct{}

func (PodSpecPathSelectorVolumesConfigMapItemsMode) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().Items().Mode().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapItemsMode) WithValue(value int32) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesConfigMapDefaultMode struct{}

func (PodSpecPathSelectorVolumesConfigMapDefaultMode) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().DefaultMode().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapDefaultMode) WithValue(value int32) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorVolumesConfigMapOptional struct{}

func (PodSpecPathSelectorVolumesConfigMapOptional) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorVolumes,
		subPath:  NewVolumeFieldPathBuilder().ConfigMap().Optional().FieldPath(),
	}
}

func (s PodSpecPathSelectorVolumesConfigMapOptional) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorCompose struct{}

func (PodSpecPathSelectorCompose) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorCompose}
}

func (s PodSpecPathSelectorCompose) WithValue(value string) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

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

type PodSpecPathSelectorHostVolumeMounts struct{}

func (PodSpecPathSelectorHostVolumeMounts) FieldPath() *PodSpec_FieldTerminalPath {
	return &PodSpec_FieldTerminalPath{selector: PodSpec_FieldPathSelectorHostVolumeMounts}
}

func (s PodSpecPathSelectorHostVolumeMounts) WithValue(value []*VolumeMount) *PodSpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldTerminalPathValue)
}

func (s PodSpecPathSelectorHostVolumeMounts) WithArrayOfValues(values [][]*VolumeMount) *PodSpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpec_FieldTerminalPathArrayOfValues)
}

func (s PodSpecPathSelectorHostVolumeMounts) WithItemValue(value *VolumeMount) *PodSpec_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpec_FieldTerminalPathArrayItemValue)
}
func (PodSpecPathSelectorHostVolumeMounts) WithSubPath(subPath VolumeMount_FieldPath) *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{selector: PodSpec_FieldPathSelectorHostVolumeMounts, subPath: subPath}
}

func (s PodSpecPathSelectorHostVolumeMounts) WithSubValue(subPathValue VolumeMount_FieldPathValue) *PodSpec_FieldSubPathValue {
	return &PodSpec_FieldSubPathValue{PodSpec_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpecPathSelectorHostVolumeMounts) WithSubArrayOfValues(subPathArrayOfValues VolumeMount_FieldPathArrayOfValues) *PodSpec_FieldSubPathArrayOfValues {
	return &PodSpec_FieldSubPathArrayOfValues{PodSpec_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpecPathSelectorHostVolumeMounts) WithSubArrayItemValue(subPathArrayItemValue VolumeMount_FieldPathArrayItemValue) *PodSpec_FieldSubPathArrayItemValue {
	return &PodSpec_FieldSubPathArrayItemValue{PodSpec_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpecPathSelectorHostVolumeMounts) Name() PodSpecPathSelectorHostVolumeMountsName {
	return PodSpecPathSelectorHostVolumeMountsName{}
}

func (PodSpecPathSelectorHostVolumeMounts) ReadOnly() PodSpecPathSelectorHostVolumeMountsReadOnly {
	return PodSpecPathSelectorHostVolumeMountsReadOnly{}
}

func (PodSpecPathSelectorHostVolumeMounts) MountPath() PodSpecPathSelectorHostVolumeMountsMountPath {
	return PodSpecPathSelectorHostVolumeMountsMountPath{}
}

func (PodSpecPathSelectorHostVolumeMounts) SubPath() PodSpecPathSelectorHostVolumeMountsSubPath {
	return PodSpecPathSelectorHostVolumeMountsSubPath{}
}

type PodSpecPathSelectorHostVolumeMountsName struct{}

func (PodSpecPathSelectorHostVolumeMountsName) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorHostVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().Name().FieldPath(),
	}
}

func (s PodSpecPathSelectorHostVolumeMountsName) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorHostVolumeMountsReadOnly struct{}

func (PodSpecPathSelectorHostVolumeMountsReadOnly) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorHostVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().ReadOnly().FieldPath(),
	}
}

func (s PodSpecPathSelectorHostVolumeMountsReadOnly) WithValue(value bool) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorHostVolumeMountsMountPath struct{}

func (PodSpecPathSelectorHostVolumeMountsMountPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorHostVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().MountPath().FieldPath(),
	}
}

func (s PodSpecPathSelectorHostVolumeMountsMountPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecPathSelectorHostVolumeMountsSubPath struct{}

func (PodSpecPathSelectorHostVolumeMountsSubPath) FieldPath() *PodSpec_FieldSubPath {
	return &PodSpec_FieldSubPath{
		selector: PodSpec_FieldPathSelectorHostVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().SubPath().FieldPath(),
	}
}

func (s PodSpecPathSelectorHostVolumeMountsSubPath) WithValue(value string) *PodSpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpec_FieldSubPathValue)
}

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

type PodSpecContainerFieldPathBuilder struct{}

func NewPodSpecContainerFieldPathBuilder() PodSpecContainerFieldPathBuilder {
	return PodSpecContainerFieldPathBuilder{}
}
func (PodSpecContainerFieldPathBuilder) Args() PodSpec_ContainerPathSelectorArgs {
	return PodSpec_ContainerPathSelectorArgs{}
}
func (PodSpecContainerFieldPathBuilder) Command() PodSpec_ContainerPathSelectorCommand {
	return PodSpec_ContainerPathSelectorCommand{}
}
func (PodSpecContainerFieldPathBuilder) Env() PodSpec_ContainerPathSelectorEnv {
	return PodSpec_ContainerPathSelectorEnv{}
}
func (PodSpecContainerFieldPathBuilder) Image() PodSpec_ContainerPathSelectorImage {
	return PodSpec_ContainerPathSelectorImage{}
}
func (PodSpecContainerFieldPathBuilder) ImagePullPolicy() PodSpec_ContainerPathSelectorImagePullPolicy {
	return PodSpec_ContainerPathSelectorImagePullPolicy{}
}
func (PodSpecContainerFieldPathBuilder) Name() PodSpec_ContainerPathSelectorName {
	return PodSpec_ContainerPathSelectorName{}
}
func (PodSpecContainerFieldPathBuilder) Resources() PodSpec_ContainerPathSelectorResources {
	return PodSpec_ContainerPathSelectorResources{}
}
func (PodSpecContainerFieldPathBuilder) SecurityContext() PodSpec_ContainerPathSelectorSecurityContext {
	return PodSpec_ContainerPathSelectorSecurityContext{}
}
func (PodSpecContainerFieldPathBuilder) VolumeMounts() PodSpec_ContainerPathSelectorVolumeMounts {
	return PodSpec_ContainerPathSelectorVolumeMounts{}
}
func (PodSpecContainerFieldPathBuilder) EnvFrom() PodSpec_ContainerPathSelectorEnvFrom {
	return PodSpec_ContainerPathSelectorEnvFrom{}
}

type PodSpec_ContainerPathSelectorArgs struct{}

func (PodSpec_ContainerPathSelectorArgs) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorArgs}
}

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

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

func (s PodSpec_ContainerPathSelectorArgs) WithItemValue(value string) *PodSpecContainer_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpecContainer_FieldTerminalPathArrayItemValue)
}

type PodSpec_ContainerPathSelectorCommand struct{}

func (PodSpec_ContainerPathSelectorCommand) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorCommand}
}

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

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

func (s PodSpec_ContainerPathSelectorCommand) WithItemValue(value string) *PodSpecContainer_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpecContainer_FieldTerminalPathArrayItemValue)
}

type PodSpec_ContainerPathSelectorEnv struct{}

func (PodSpec_ContainerPathSelectorEnv) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorEnv}
}

func (s PodSpec_ContainerPathSelectorEnv) WithValue(value []*EnvVar) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

func (s PodSpec_ContainerPathSelectorEnv) WithArrayOfValues(values [][]*EnvVar) *PodSpecContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldTerminalPathArrayOfValues)
}

func (s PodSpec_ContainerPathSelectorEnv) WithItemValue(value *EnvVar) *PodSpecContainer_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpecContainer_FieldTerminalPathArrayItemValue)
}
func (PodSpec_ContainerPathSelectorEnv) WithSubPath(subPath EnvVar_FieldPath) *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{selector: PodSpecContainer_FieldPathSelectorEnv, subPath: subPath}
}

func (s PodSpec_ContainerPathSelectorEnv) WithSubValue(subPathValue EnvVar_FieldPathValue) *PodSpecContainer_FieldSubPathValue {
	return &PodSpecContainer_FieldSubPathValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpec_ContainerPathSelectorEnv) WithSubArrayOfValues(subPathArrayOfValues EnvVar_FieldPathArrayOfValues) *PodSpecContainer_FieldSubPathArrayOfValues {
	return &PodSpecContainer_FieldSubPathArrayOfValues{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpec_ContainerPathSelectorEnv) WithSubArrayItemValue(subPathArrayItemValue EnvVar_FieldPathArrayItemValue) *PodSpecContainer_FieldSubPathArrayItemValue {
	return &PodSpecContainer_FieldSubPathArrayItemValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpec_ContainerPathSelectorEnv) Name() PodSpec_ContainerPathSelectorEnvName {
	return PodSpec_ContainerPathSelectorEnvName{}
}

func (PodSpec_ContainerPathSelectorEnv) Value() PodSpec_ContainerPathSelectorEnvValue {
	return PodSpec_ContainerPathSelectorEnvValue{}
}

func (PodSpec_ContainerPathSelectorEnv) ValueFrom() PodSpec_ContainerPathSelectorEnvValueFrom {
	return PodSpec_ContainerPathSelectorEnvValueFrom{}
}

type PodSpec_ContainerPathSelectorEnvName struct{}

func (PodSpec_ContainerPathSelectorEnvName) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().Name().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvName) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValue struct{}

func (PodSpec_ContainerPathSelectorEnvValue) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().Value().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValue) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValueFrom struct{}

func (PodSpec_ContainerPathSelectorEnvValueFrom) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFrom) WithValue(value *EnvVarSource) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

func (s PodSpec_ContainerPathSelectorEnvValueFrom) WithArrayOfValues(values []*EnvVarSource) *PodSpecContainer_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldSubPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorEnvValueFrom) ConfigMapKeyRef() PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef {
	return PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef{}
}

func (PodSpec_ContainerPathSelectorEnvValueFrom) SecretKeyRef() PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef {
	return PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef{}
}

type PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().ConfigMapKeyRef().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef) WithValue(value *ConfigMapKeySelector) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

func (s PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef) WithArrayOfValues(values []*ConfigMapKeySelector) *PodSpecContainer_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldSubPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef) Name() PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefName {
	return PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefName{}
}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef) Key() PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefKey {
	return PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefKey{}
}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRef) Optional() PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefOptional {
	return PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefOptional{}
}

type PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefName struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefName) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().ConfigMapKeyRef().Name().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefName) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefKey struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefKey) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().ConfigMapKeyRef().Key().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefKey) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefOptional struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefOptional) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().ConfigMapKeyRef().Optional().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromConfigMapKeyRefOptional) WithValue(value bool) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().SecretKeyRef().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef) WithValue(value *SecretKeySelector) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

func (s PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef) WithArrayOfValues(values []*SecretKeySelector) *PodSpecContainer_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldSubPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef) Name() PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefName {
	return PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefName{}
}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef) Key() PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefKey {
	return PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefKey{}
}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRef) Optional() PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefOptional {
	return PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefOptional{}
}

type PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefName struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefName) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().SecretKeyRef().Name().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefName) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefKey struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefKey) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().SecretKeyRef().Key().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefKey) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefOptional struct{}

func (PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefOptional) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnv,
		subPath:  NewEnvVarFieldPathBuilder().ValueFrom().SecretKeyRef().Optional().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvValueFromSecretKeyRefOptional) WithValue(value bool) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorImage struct{}

func (PodSpec_ContainerPathSelectorImage) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorImage}
}

func (s PodSpec_ContainerPathSelectorImage) WithValue(value string) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

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

type PodSpec_ContainerPathSelectorImagePullPolicy struct{}

func (PodSpec_ContainerPathSelectorImagePullPolicy) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorImagePullPolicy}
}

func (s PodSpec_ContainerPathSelectorImagePullPolicy) WithValue(value string) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

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

type PodSpec_ContainerPathSelectorName struct{}

func (PodSpec_ContainerPathSelectorName) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorName}
}

func (s PodSpec_ContainerPathSelectorName) WithValue(value string) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

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

type PodSpec_ContainerPathSelectorResources struct{}

func (PodSpec_ContainerPathSelectorResources) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorResources}
}

func (s PodSpec_ContainerPathSelectorResources) WithValue(value *PodSpec_Container_ResourceRequirements) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

func (s PodSpec_ContainerPathSelectorResources) WithArrayOfValues(values []*PodSpec_Container_ResourceRequirements) *PodSpecContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldTerminalPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorResources) WithSubPath(subPath PodSpecContainerResourceRequirements_FieldPath) *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{selector: PodSpecContainer_FieldPathSelectorResources, subPath: subPath}
}

func (s PodSpec_ContainerPathSelectorResources) WithSubValue(subPathValue PodSpecContainerResourceRequirements_FieldPathValue) *PodSpecContainer_FieldSubPathValue {
	return &PodSpecContainer_FieldSubPathValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpec_ContainerPathSelectorResources) WithSubArrayOfValues(subPathArrayOfValues PodSpecContainerResourceRequirements_FieldPathArrayOfValues) *PodSpecContainer_FieldSubPathArrayOfValues {
	return &PodSpecContainer_FieldSubPathArrayOfValues{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpec_ContainerPathSelectorResources) WithSubArrayItemValue(subPathArrayItemValue PodSpecContainerResourceRequirements_FieldPathArrayItemValue) *PodSpecContainer_FieldSubPathArrayItemValue {
	return &PodSpecContainer_FieldSubPathArrayItemValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpec_ContainerPathSelectorResources) Limits() PodSpec_ContainerPathSelectorResourcesLimits {
	return PodSpec_ContainerPathSelectorResourcesLimits{}
}

func (PodSpec_ContainerPathSelectorResources) Requests() PodSpec_ContainerPathSelectorResourcesRequests {
	return PodSpec_ContainerPathSelectorResourcesRequests{}
}

type PodSpec_ContainerPathSelectorResourcesLimits struct{}

func (PodSpec_ContainerPathSelectorResourcesLimits) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorResources,
		subPath:  NewPodSpecContainerResourceRequirementsFieldPathBuilder().Limits().FieldPath(),
	}
}

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

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

func (PodSpec_ContainerPathSelectorResourcesLimits) WithKey(key string) PodSpec_ContainerMapPathSelectorResourcesLimits {
	return PodSpec_ContainerMapPathSelectorResourcesLimits{key: key}
}

type PodSpec_ContainerMapPathSelectorResourcesLimits struct {
	key string
}

func (s PodSpec_ContainerMapPathSelectorResourcesLimits) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorResources,
		subPath:  NewPodSpecContainerResourceRequirementsFieldPathBuilder().Limits().WithKey(s.key).FieldPath(),
	}
}

func (s PodSpec_ContainerMapPathSelectorResourcesLimits) WithValue(value int64) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorResourcesRequests struct{}

func (PodSpec_ContainerPathSelectorResourcesRequests) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorResources,
		subPath:  NewPodSpecContainerResourceRequirementsFieldPathBuilder().Requests().FieldPath(),
	}
}

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

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

func (PodSpec_ContainerPathSelectorResourcesRequests) WithKey(key string) PodSpec_ContainerMapPathSelectorResourcesRequests {
	return PodSpec_ContainerMapPathSelectorResourcesRequests{key: key}
}

type PodSpec_ContainerMapPathSelectorResourcesRequests struct {
	key string
}

func (s PodSpec_ContainerMapPathSelectorResourcesRequests) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorResources,
		subPath:  NewPodSpecContainerResourceRequirementsFieldPathBuilder().Requests().WithKey(s.key).FieldPath(),
	}
}

func (s PodSpec_ContainerMapPathSelectorResourcesRequests) WithValue(value int64) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorSecurityContext struct{}

func (PodSpec_ContainerPathSelectorSecurityContext) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorSecurityContext}
}

func (s PodSpec_ContainerPathSelectorSecurityContext) WithValue(value *SecurityContext) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

func (s PodSpec_ContainerPathSelectorSecurityContext) WithArrayOfValues(values []*SecurityContext) *PodSpecContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldTerminalPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorSecurityContext) WithSubPath(subPath SecurityContext_FieldPath) *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{selector: PodSpecContainer_FieldPathSelectorSecurityContext, subPath: subPath}
}

func (s PodSpec_ContainerPathSelectorSecurityContext) WithSubValue(subPathValue SecurityContext_FieldPathValue) *PodSpecContainer_FieldSubPathValue {
	return &PodSpecContainer_FieldSubPathValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpec_ContainerPathSelectorSecurityContext) WithSubArrayOfValues(subPathArrayOfValues SecurityContext_FieldPathArrayOfValues) *PodSpecContainer_FieldSubPathArrayOfValues {
	return &PodSpecContainer_FieldSubPathArrayOfValues{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpec_ContainerPathSelectorSecurityContext) WithSubArrayItemValue(subPathArrayItemValue SecurityContext_FieldPathArrayItemValue) *PodSpecContainer_FieldSubPathArrayItemValue {
	return &PodSpecContainer_FieldSubPathArrayItemValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpec_ContainerPathSelectorSecurityContext) Privileged() PodSpec_ContainerPathSelectorSecurityContextPrivileged {
	return PodSpec_ContainerPathSelectorSecurityContextPrivileged{}
}

type PodSpec_ContainerPathSelectorSecurityContextPrivileged struct{}

func (PodSpec_ContainerPathSelectorSecurityContextPrivileged) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorSecurityContext,
		subPath:  NewSecurityContextFieldPathBuilder().Privileged().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorSecurityContextPrivileged) WithValue(value bool) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorVolumeMounts struct{}

func (PodSpec_ContainerPathSelectorVolumeMounts) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorVolumeMounts}
}

func (s PodSpec_ContainerPathSelectorVolumeMounts) WithValue(value []*VolumeMount) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

func (s PodSpec_ContainerPathSelectorVolumeMounts) WithArrayOfValues(values [][]*VolumeMount) *PodSpecContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldTerminalPathArrayOfValues)
}

func (s PodSpec_ContainerPathSelectorVolumeMounts) WithItemValue(value *VolumeMount) *PodSpecContainer_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*PodSpecContainer_FieldTerminalPathArrayItemValue)
}
func (PodSpec_ContainerPathSelectorVolumeMounts) WithSubPath(subPath VolumeMount_FieldPath) *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{selector: PodSpecContainer_FieldPathSelectorVolumeMounts, subPath: subPath}
}

func (s PodSpec_ContainerPathSelectorVolumeMounts) WithSubValue(subPathValue VolumeMount_FieldPathValue) *PodSpecContainer_FieldSubPathValue {
	return &PodSpecContainer_FieldSubPathValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpec_ContainerPathSelectorVolumeMounts) WithSubArrayOfValues(subPathArrayOfValues VolumeMount_FieldPathArrayOfValues) *PodSpecContainer_FieldSubPathArrayOfValues {
	return &PodSpecContainer_FieldSubPathArrayOfValues{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpec_ContainerPathSelectorVolumeMounts) WithSubArrayItemValue(subPathArrayItemValue VolumeMount_FieldPathArrayItemValue) *PodSpecContainer_FieldSubPathArrayItemValue {
	return &PodSpecContainer_FieldSubPathArrayItemValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpec_ContainerPathSelectorVolumeMounts) Name() PodSpec_ContainerPathSelectorVolumeMountsName {
	return PodSpec_ContainerPathSelectorVolumeMountsName{}
}

func (PodSpec_ContainerPathSelectorVolumeMounts) ReadOnly() PodSpec_ContainerPathSelectorVolumeMountsReadOnly {
	return PodSpec_ContainerPathSelectorVolumeMountsReadOnly{}
}

func (PodSpec_ContainerPathSelectorVolumeMounts) MountPath() PodSpec_ContainerPathSelectorVolumeMountsMountPath {
	return PodSpec_ContainerPathSelectorVolumeMountsMountPath{}
}

func (PodSpec_ContainerPathSelectorVolumeMounts) SubPath() PodSpec_ContainerPathSelectorVolumeMountsSubPath {
	return PodSpec_ContainerPathSelectorVolumeMountsSubPath{}
}

type PodSpec_ContainerPathSelectorVolumeMountsName struct{}

func (PodSpec_ContainerPathSelectorVolumeMountsName) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().Name().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorVolumeMountsName) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorVolumeMountsReadOnly struct{}

func (PodSpec_ContainerPathSelectorVolumeMountsReadOnly) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().ReadOnly().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorVolumeMountsReadOnly) WithValue(value bool) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorVolumeMountsMountPath struct{}

func (PodSpec_ContainerPathSelectorVolumeMountsMountPath) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().MountPath().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorVolumeMountsMountPath) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorVolumeMountsSubPath struct{}

func (PodSpec_ContainerPathSelectorVolumeMountsSubPath) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorVolumeMounts,
		subPath:  NewVolumeMountFieldPathBuilder().SubPath().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorVolumeMountsSubPath) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvFrom struct{}

func (PodSpec_ContainerPathSelectorEnvFrom) FieldPath() *PodSpecContainer_FieldTerminalPath {
	return &PodSpecContainer_FieldTerminalPath{selector: PodSpecContainer_FieldPathSelectorEnvFrom}
}

func (s PodSpec_ContainerPathSelectorEnvFrom) WithValue(value *EnvFromSource) *PodSpecContainer_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldTerminalPathValue)
}

func (s PodSpec_ContainerPathSelectorEnvFrom) WithArrayOfValues(values []*EnvFromSource) *PodSpecContainer_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldTerminalPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorEnvFrom) WithSubPath(subPath EnvFromSource_FieldPath) *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{selector: PodSpecContainer_FieldPathSelectorEnvFrom, subPath: subPath}
}

func (s PodSpec_ContainerPathSelectorEnvFrom) WithSubValue(subPathValue EnvFromSource_FieldPathValue) *PodSpecContainer_FieldSubPathValue {
	return &PodSpecContainer_FieldSubPathValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s PodSpec_ContainerPathSelectorEnvFrom) WithSubArrayOfValues(subPathArrayOfValues EnvFromSource_FieldPathArrayOfValues) *PodSpecContainer_FieldSubPathArrayOfValues {
	return &PodSpecContainer_FieldSubPathArrayOfValues{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s PodSpec_ContainerPathSelectorEnvFrom) WithSubArrayItemValue(subPathArrayItemValue EnvFromSource_FieldPathArrayItemValue) *PodSpecContainer_FieldSubPathArrayItemValue {
	return &PodSpecContainer_FieldSubPathArrayItemValue{PodSpecContainer_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (PodSpec_ContainerPathSelectorEnvFrom) Prefix() PodSpec_ContainerPathSelectorEnvFromPrefix {
	return PodSpec_ContainerPathSelectorEnvFromPrefix{}
}

func (PodSpec_ContainerPathSelectorEnvFrom) ConfigMapRef() PodSpec_ContainerPathSelectorEnvFromConfigMapRef {
	return PodSpec_ContainerPathSelectorEnvFromConfigMapRef{}
}

func (PodSpec_ContainerPathSelectorEnvFrom) SecretRef() PodSpec_ContainerPathSelectorEnvFromSecretRef {
	return PodSpec_ContainerPathSelectorEnvFromSecretRef{}
}

type PodSpec_ContainerPathSelectorEnvFromPrefix struct{}

func (PodSpec_ContainerPathSelectorEnvFromPrefix) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().Prefix().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromPrefix) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvFromConfigMapRef struct{}

func (PodSpec_ContainerPathSelectorEnvFromConfigMapRef) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().ConfigMapRef().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromConfigMapRef) WithValue(value *ConfigMapEnvSource) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

func (s PodSpec_ContainerPathSelectorEnvFromConfigMapRef) WithArrayOfValues(values []*ConfigMapEnvSource) *PodSpecContainer_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldSubPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorEnvFromConfigMapRef) Name() PodSpec_ContainerPathSelectorEnvFromConfigMapRefName {
	return PodSpec_ContainerPathSelectorEnvFromConfigMapRefName{}
}

func (PodSpec_ContainerPathSelectorEnvFromConfigMapRef) Optional() PodSpec_ContainerPathSelectorEnvFromConfigMapRefOptional {
	return PodSpec_ContainerPathSelectorEnvFromConfigMapRefOptional{}
}

type PodSpec_ContainerPathSelectorEnvFromConfigMapRefName struct{}

func (PodSpec_ContainerPathSelectorEnvFromConfigMapRefName) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().ConfigMapRef().Name().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromConfigMapRefName) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvFromConfigMapRefOptional struct{}

func (PodSpec_ContainerPathSelectorEnvFromConfigMapRefOptional) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().ConfigMapRef().Optional().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromConfigMapRefOptional) WithValue(value bool) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvFromSecretRef struct{}

func (PodSpec_ContainerPathSelectorEnvFromSecretRef) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().SecretRef().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromSecretRef) WithValue(value *SecretEnvSource) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

func (s PodSpec_ContainerPathSelectorEnvFromSecretRef) WithArrayOfValues(values []*SecretEnvSource) *PodSpecContainer_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*PodSpecContainer_FieldSubPathArrayOfValues)
}

func (PodSpec_ContainerPathSelectorEnvFromSecretRef) Name() PodSpec_ContainerPathSelectorEnvFromSecretRefName {
	return PodSpec_ContainerPathSelectorEnvFromSecretRefName{}
}

func (PodSpec_ContainerPathSelectorEnvFromSecretRef) Optional() PodSpec_ContainerPathSelectorEnvFromSecretRefOptional {
	return PodSpec_ContainerPathSelectorEnvFromSecretRefOptional{}
}

type PodSpec_ContainerPathSelectorEnvFromSecretRefName struct{}

func (PodSpec_ContainerPathSelectorEnvFromSecretRefName) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().SecretRef().Name().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromSecretRefName) WithValue(value string) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpec_ContainerPathSelectorEnvFromSecretRefOptional struct{}

func (PodSpec_ContainerPathSelectorEnvFromSecretRefOptional) FieldPath() *PodSpecContainer_FieldSubPath {
	return &PodSpecContainer_FieldSubPath{
		selector: PodSpecContainer_FieldPathSelectorEnvFrom,
		subPath:  NewEnvFromSourceFieldPathBuilder().SecretRef().Optional().FieldPath(),
	}
}

func (s PodSpec_ContainerPathSelectorEnvFromSecretRefOptional) WithValue(value bool) *PodSpecContainer_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainer_FieldSubPathValue)
}

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

type PodSpecContainerResourceRequirementsFieldPathBuilder struct{}

func NewPodSpecContainerResourceRequirementsFieldPathBuilder() PodSpecContainerResourceRequirementsFieldPathBuilder {
	return PodSpecContainerResourceRequirementsFieldPathBuilder{}
}
func (PodSpecContainerResourceRequirementsFieldPathBuilder) Limits() PodSpec_Container_ResourceRequirementsPathSelectorLimits {
	return PodSpec_Container_ResourceRequirementsPathSelectorLimits{}
}
func (PodSpecContainerResourceRequirementsFieldPathBuilder) Requests() PodSpec_Container_ResourceRequirementsPathSelectorRequests {
	return PodSpec_Container_ResourceRequirementsPathSelectorRequests{}
}

type PodSpec_Container_ResourceRequirementsPathSelectorLimits struct{}

func (PodSpec_Container_ResourceRequirementsPathSelectorLimits) FieldPath() *PodSpecContainerResourceRequirements_FieldTerminalPath {
	return &PodSpecContainerResourceRequirements_FieldTerminalPath{selector: PodSpecContainerResourceRequirements_FieldPathSelectorLimits}
}

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

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

func (PodSpec_Container_ResourceRequirementsPathSelectorLimits) WithKey(key string) PodSpec_Container_ResourceRequirementsMapPathSelectorLimits {
	return PodSpec_Container_ResourceRequirementsMapPathSelectorLimits{key: key}
}

type PodSpec_Container_ResourceRequirementsMapPathSelectorLimits struct {
	key string
}

func (s PodSpec_Container_ResourceRequirementsMapPathSelectorLimits) FieldPath() *PodSpecContainerResourceRequirements_FieldPathMap {
	return &PodSpecContainerResourceRequirements_FieldPathMap{selector: PodSpecContainerResourceRequirements_FieldPathSelectorLimits, key: s.key}
}

func (s PodSpec_Container_ResourceRequirementsMapPathSelectorLimits) WithValue(value int64) *PodSpecContainerResourceRequirements_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainerResourceRequirements_FieldPathMapValue)
}

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

type PodSpec_Container_ResourceRequirementsPathSelectorRequests struct{}

func (PodSpec_Container_ResourceRequirementsPathSelectorRequests) FieldPath() *PodSpecContainerResourceRequirements_FieldTerminalPath {
	return &PodSpecContainerResourceRequirements_FieldTerminalPath{selector: PodSpecContainerResourceRequirements_FieldPathSelectorRequests}
}

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

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

func (PodSpec_Container_ResourceRequirementsPathSelectorRequests) WithKey(key string) PodSpec_Container_ResourceRequirementsMapPathSelectorRequests {
	return PodSpec_Container_ResourceRequirementsMapPathSelectorRequests{key: key}
}

type PodSpec_Container_ResourceRequirementsMapPathSelectorRequests struct {
	key string
}

func (s PodSpec_Container_ResourceRequirementsMapPathSelectorRequests) FieldPath() *PodSpecContainerResourceRequirements_FieldPathMap {
	return &PodSpecContainerResourceRequirements_FieldPathMap{selector: PodSpecContainerResourceRequirements_FieldPathSelectorRequests, key: s.key}
}

func (s PodSpec_Container_ResourceRequirementsMapPathSelectorRequests) WithValue(value int64) *PodSpecContainerResourceRequirements_FieldPathMapValue {
	return s.FieldPath().WithIValue(value).(*PodSpecContainerResourceRequirements_FieldPathMapValue)
}

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

type EnvFromSourceFieldPathBuilder struct{}

func NewEnvFromSourceFieldPathBuilder() EnvFromSourceFieldPathBuilder {
	return EnvFromSourceFieldPathBuilder{}
}
func (EnvFromSourceFieldPathBuilder) Prefix() EnvFromSourcePathSelectorPrefix {
	return EnvFromSourcePathSelectorPrefix{}
}
func (EnvFromSourceFieldPathBuilder) ConfigMapRef() EnvFromSourcePathSelectorConfigMapRef {
	return EnvFromSourcePathSelectorConfigMapRef{}
}
func (EnvFromSourceFieldPathBuilder) SecretRef() EnvFromSourcePathSelectorSecretRef {
	return EnvFromSourcePathSelectorSecretRef{}
}

type EnvFromSourcePathSelectorPrefix struct{}

func (EnvFromSourcePathSelectorPrefix) FieldPath() *EnvFromSource_FieldTerminalPath {
	return &EnvFromSource_FieldTerminalPath{selector: EnvFromSource_FieldPathSelectorPrefix}
}

func (s EnvFromSourcePathSelectorPrefix) WithValue(value string) *EnvFromSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldTerminalPathValue)
}

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

type EnvFromSourcePathSelectorConfigMapRef struct{}

func (EnvFromSourcePathSelectorConfigMapRef) FieldPath() *EnvFromSource_FieldTerminalPath {
	return &EnvFromSource_FieldTerminalPath{selector: EnvFromSource_FieldPathSelectorConfigMapRef}
}

func (s EnvFromSourcePathSelectorConfigMapRef) WithValue(value *ConfigMapEnvSource) *EnvFromSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldTerminalPathValue)
}

func (s EnvFromSourcePathSelectorConfigMapRef) WithArrayOfValues(values []*ConfigMapEnvSource) *EnvFromSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvFromSource_FieldTerminalPathArrayOfValues)
}

func (EnvFromSourcePathSelectorConfigMapRef) WithSubPath(subPath ConfigMapEnvSource_FieldPath) *EnvFromSource_FieldSubPath {
	return &EnvFromSource_FieldSubPath{selector: EnvFromSource_FieldPathSelectorConfigMapRef, subPath: subPath}
}

func (s EnvFromSourcePathSelectorConfigMapRef) WithSubValue(subPathValue ConfigMapEnvSource_FieldPathValue) *EnvFromSource_FieldSubPathValue {
	return &EnvFromSource_FieldSubPathValue{EnvFromSource_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s EnvFromSourcePathSelectorConfigMapRef) WithSubArrayOfValues(subPathArrayOfValues ConfigMapEnvSource_FieldPathArrayOfValues) *EnvFromSource_FieldSubPathArrayOfValues {
	return &EnvFromSource_FieldSubPathArrayOfValues{EnvFromSource_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s EnvFromSourcePathSelectorConfigMapRef) WithSubArrayItemValue(subPathArrayItemValue ConfigMapEnvSource_FieldPathArrayItemValue) *EnvFromSource_FieldSubPathArrayItemValue {
	return &EnvFromSource_FieldSubPathArrayItemValue{EnvFromSource_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (EnvFromSourcePathSelectorConfigMapRef) Name() EnvFromSourcePathSelectorConfigMapRefName {
	return EnvFromSourcePathSelectorConfigMapRefName{}
}

func (EnvFromSourcePathSelectorConfigMapRef) Optional() EnvFromSourcePathSelectorConfigMapRefOptional {
	return EnvFromSourcePathSelectorConfigMapRefOptional{}
}

type EnvFromSourcePathSelectorConfigMapRefName struct{}

func (EnvFromSourcePathSelectorConfigMapRefName) FieldPath() *EnvFromSource_FieldSubPath {
	return &EnvFromSource_FieldSubPath{
		selector: EnvFromSource_FieldPathSelectorConfigMapRef,
		subPath:  NewConfigMapEnvSourceFieldPathBuilder().Name().FieldPath(),
	}
}

func (s EnvFromSourcePathSelectorConfigMapRefName) WithValue(value string) *EnvFromSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldSubPathValue)
}

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

type EnvFromSourcePathSelectorConfigMapRefOptional struct{}

func (EnvFromSourcePathSelectorConfigMapRefOptional) FieldPath() *EnvFromSource_FieldSubPath {
	return &EnvFromSource_FieldSubPath{
		selector: EnvFromSource_FieldPathSelectorConfigMapRef,
		subPath:  NewConfigMapEnvSourceFieldPathBuilder().Optional().FieldPath(),
	}
}

func (s EnvFromSourcePathSelectorConfigMapRefOptional) WithValue(value bool) *EnvFromSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldSubPathValue)
}

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

type EnvFromSourcePathSelectorSecretRef struct{}

func (EnvFromSourcePathSelectorSecretRef) FieldPath() *EnvFromSource_FieldTerminalPath {
	return &EnvFromSource_FieldTerminalPath{selector: EnvFromSource_FieldPathSelectorSecretRef}
}

func (s EnvFromSourcePathSelectorSecretRef) WithValue(value *SecretEnvSource) *EnvFromSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldTerminalPathValue)
}

func (s EnvFromSourcePathSelectorSecretRef) WithArrayOfValues(values []*SecretEnvSource) *EnvFromSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvFromSource_FieldTerminalPathArrayOfValues)
}

func (EnvFromSourcePathSelectorSecretRef) WithSubPath(subPath SecretEnvSource_FieldPath) *EnvFromSource_FieldSubPath {
	return &EnvFromSource_FieldSubPath{selector: EnvFromSource_FieldPathSelectorSecretRef, subPath: subPath}
}

func (s EnvFromSourcePathSelectorSecretRef) WithSubValue(subPathValue SecretEnvSource_FieldPathValue) *EnvFromSource_FieldSubPathValue {
	return &EnvFromSource_FieldSubPathValue{EnvFromSource_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s EnvFromSourcePathSelectorSecretRef) WithSubArrayOfValues(subPathArrayOfValues SecretEnvSource_FieldPathArrayOfValues) *EnvFromSource_FieldSubPathArrayOfValues {
	return &EnvFromSource_FieldSubPathArrayOfValues{EnvFromSource_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s EnvFromSourcePathSelectorSecretRef) WithSubArrayItemValue(subPathArrayItemValue SecretEnvSource_FieldPathArrayItemValue) *EnvFromSource_FieldSubPathArrayItemValue {
	return &EnvFromSource_FieldSubPathArrayItemValue{EnvFromSource_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (EnvFromSourcePathSelectorSecretRef) Name() EnvFromSourcePathSelectorSecretRefName {
	return EnvFromSourcePathSelectorSecretRefName{}
}

func (EnvFromSourcePathSelectorSecretRef) Optional() EnvFromSourcePathSelectorSecretRefOptional {
	return EnvFromSourcePathSelectorSecretRefOptional{}
}

type EnvFromSourcePathSelectorSecretRefName struct{}

func (EnvFromSourcePathSelectorSecretRefName) FieldPath() *EnvFromSource_FieldSubPath {
	return &EnvFromSource_FieldSubPath{
		selector: EnvFromSource_FieldPathSelectorSecretRef,
		subPath:  NewSecretEnvSourceFieldPathBuilder().Name().FieldPath(),
	}
}

func (s EnvFromSourcePathSelectorSecretRefName) WithValue(value string) *EnvFromSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldSubPathValue)
}

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

type EnvFromSourcePathSelectorSecretRefOptional struct{}

func (EnvFromSourcePathSelectorSecretRefOptional) FieldPath() *EnvFromSource_FieldSubPath {
	return &EnvFromSource_FieldSubPath{
		selector: EnvFromSource_FieldPathSelectorSecretRef,
		subPath:  NewSecretEnvSourceFieldPathBuilder().Optional().FieldPath(),
	}
}

func (s EnvFromSourcePathSelectorSecretRefOptional) WithValue(value bool) *EnvFromSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvFromSource_FieldSubPathValue)
}

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

type EnvVarFieldPathBuilder struct{}

func NewEnvVarFieldPathBuilder() EnvVarFieldPathBuilder {
	return EnvVarFieldPathBuilder{}
}
func (EnvVarFieldPathBuilder) Name() EnvVarPathSelectorName {
	return EnvVarPathSelectorName{}
}
func (EnvVarFieldPathBuilder) Value() EnvVarPathSelectorValue {
	return EnvVarPathSelectorValue{}
}
func (EnvVarFieldPathBuilder) ValueFrom() EnvVarPathSelectorValueFrom {
	return EnvVarPathSelectorValueFrom{}
}

type EnvVarPathSelectorName struct{}

func (EnvVarPathSelectorName) FieldPath() *EnvVar_FieldTerminalPath {
	return &EnvVar_FieldTerminalPath{selector: EnvVar_FieldPathSelectorName}
}

func (s EnvVarPathSelectorName) WithValue(value string) *EnvVar_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldTerminalPathValue)
}

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

type EnvVarPathSelectorValue struct{}

func (EnvVarPathSelectorValue) FieldPath() *EnvVar_FieldTerminalPath {
	return &EnvVar_FieldTerminalPath{selector: EnvVar_FieldPathSelectorValue}
}

func (s EnvVarPathSelectorValue) WithValue(value string) *EnvVar_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldTerminalPathValue)
}

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

type EnvVarPathSelectorValueFrom struct{}

func (EnvVarPathSelectorValueFrom) FieldPath() *EnvVar_FieldTerminalPath {
	return &EnvVar_FieldTerminalPath{selector: EnvVar_FieldPathSelectorValueFrom}
}

func (s EnvVarPathSelectorValueFrom) WithValue(value *EnvVarSource) *EnvVar_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldTerminalPathValue)
}

func (s EnvVarPathSelectorValueFrom) WithArrayOfValues(values []*EnvVarSource) *EnvVar_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvVar_FieldTerminalPathArrayOfValues)
}

func (EnvVarPathSelectorValueFrom) WithSubPath(subPath EnvVarSource_FieldPath) *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{selector: EnvVar_FieldPathSelectorValueFrom, subPath: subPath}
}

func (s EnvVarPathSelectorValueFrom) WithSubValue(subPathValue EnvVarSource_FieldPathValue) *EnvVar_FieldSubPathValue {
	return &EnvVar_FieldSubPathValue{EnvVar_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s EnvVarPathSelectorValueFrom) WithSubArrayOfValues(subPathArrayOfValues EnvVarSource_FieldPathArrayOfValues) *EnvVar_FieldSubPathArrayOfValues {
	return &EnvVar_FieldSubPathArrayOfValues{EnvVar_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s EnvVarPathSelectorValueFrom) WithSubArrayItemValue(subPathArrayItemValue EnvVarSource_FieldPathArrayItemValue) *EnvVar_FieldSubPathArrayItemValue {
	return &EnvVar_FieldSubPathArrayItemValue{EnvVar_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (EnvVarPathSelectorValueFrom) ConfigMapKeyRef() EnvVarPathSelectorValueFromConfigMapKeyRef {
	return EnvVarPathSelectorValueFromConfigMapKeyRef{}
}

func (EnvVarPathSelectorValueFrom) SecretKeyRef() EnvVarPathSelectorValueFromSecretKeyRef {
	return EnvVarPathSelectorValueFromSecretKeyRef{}
}

type EnvVarPathSelectorValueFromConfigMapKeyRef struct{}

func (EnvVarPathSelectorValueFromConfigMapKeyRef) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().ConfigMapKeyRef().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromConfigMapKeyRef) WithValue(value *ConfigMapKeySelector) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

func (s EnvVarPathSelectorValueFromConfigMapKeyRef) WithArrayOfValues(values []*ConfigMapKeySelector) *EnvVar_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvVar_FieldSubPathArrayOfValues)
}

func (EnvVarPathSelectorValueFromConfigMapKeyRef) Name() EnvVarPathSelectorValueFromConfigMapKeyRefName {
	return EnvVarPathSelectorValueFromConfigMapKeyRefName{}
}

func (EnvVarPathSelectorValueFromConfigMapKeyRef) Key() EnvVarPathSelectorValueFromConfigMapKeyRefKey {
	return EnvVarPathSelectorValueFromConfigMapKeyRefKey{}
}

func (EnvVarPathSelectorValueFromConfigMapKeyRef) Optional() EnvVarPathSelectorValueFromConfigMapKeyRefOptional {
	return EnvVarPathSelectorValueFromConfigMapKeyRefOptional{}
}

type EnvVarPathSelectorValueFromConfigMapKeyRefName struct{}

func (EnvVarPathSelectorValueFromConfigMapKeyRefName) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().ConfigMapKeyRef().Name().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromConfigMapKeyRefName) WithValue(value string) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

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

type EnvVarPathSelectorValueFromConfigMapKeyRefKey struct{}

func (EnvVarPathSelectorValueFromConfigMapKeyRefKey) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().ConfigMapKeyRef().Key().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromConfigMapKeyRefKey) WithValue(value string) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

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

type EnvVarPathSelectorValueFromConfigMapKeyRefOptional struct{}

func (EnvVarPathSelectorValueFromConfigMapKeyRefOptional) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().ConfigMapKeyRef().Optional().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromConfigMapKeyRefOptional) WithValue(value bool) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

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

type EnvVarPathSelectorValueFromSecretKeyRef struct{}

func (EnvVarPathSelectorValueFromSecretKeyRef) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().SecretKeyRef().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromSecretKeyRef) WithValue(value *SecretKeySelector) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

func (s EnvVarPathSelectorValueFromSecretKeyRef) WithArrayOfValues(values []*SecretKeySelector) *EnvVar_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvVar_FieldSubPathArrayOfValues)
}

func (EnvVarPathSelectorValueFromSecretKeyRef) Name() EnvVarPathSelectorValueFromSecretKeyRefName {
	return EnvVarPathSelectorValueFromSecretKeyRefName{}
}

func (EnvVarPathSelectorValueFromSecretKeyRef) Key() EnvVarPathSelectorValueFromSecretKeyRefKey {
	return EnvVarPathSelectorValueFromSecretKeyRefKey{}
}

func (EnvVarPathSelectorValueFromSecretKeyRef) Optional() EnvVarPathSelectorValueFromSecretKeyRefOptional {
	return EnvVarPathSelectorValueFromSecretKeyRefOptional{}
}

type EnvVarPathSelectorValueFromSecretKeyRefName struct{}

func (EnvVarPathSelectorValueFromSecretKeyRefName) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().SecretKeyRef().Name().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromSecretKeyRefName) WithValue(value string) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

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

type EnvVarPathSelectorValueFromSecretKeyRefKey struct{}

func (EnvVarPathSelectorValueFromSecretKeyRefKey) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().SecretKeyRef().Key().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromSecretKeyRefKey) WithValue(value string) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

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

type EnvVarPathSelectorValueFromSecretKeyRefOptional struct{}

func (EnvVarPathSelectorValueFromSecretKeyRefOptional) FieldPath() *EnvVar_FieldSubPath {
	return &EnvVar_FieldSubPath{
		selector: EnvVar_FieldPathSelectorValueFrom,
		subPath:  NewEnvVarSourceFieldPathBuilder().SecretKeyRef().Optional().FieldPath(),
	}
}

func (s EnvVarPathSelectorValueFromSecretKeyRefOptional) WithValue(value bool) *EnvVar_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVar_FieldSubPathValue)
}

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

type ConfigMapEnvSourceFieldPathBuilder struct{}

func NewConfigMapEnvSourceFieldPathBuilder() ConfigMapEnvSourceFieldPathBuilder {
	return ConfigMapEnvSourceFieldPathBuilder{}
}
func (ConfigMapEnvSourceFieldPathBuilder) Name() ConfigMapEnvSourcePathSelectorName {
	return ConfigMapEnvSourcePathSelectorName{}
}
func (ConfigMapEnvSourceFieldPathBuilder) Optional() ConfigMapEnvSourcePathSelectorOptional {
	return ConfigMapEnvSourcePathSelectorOptional{}
}

type ConfigMapEnvSourcePathSelectorName struct{}

func (ConfigMapEnvSourcePathSelectorName) FieldPath() *ConfigMapEnvSource_FieldTerminalPath {
	return &ConfigMapEnvSource_FieldTerminalPath{selector: ConfigMapEnvSource_FieldPathSelectorName}
}

func (s ConfigMapEnvSourcePathSelectorName) WithValue(value string) *ConfigMapEnvSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapEnvSource_FieldTerminalPathValue)
}

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

type ConfigMapEnvSourcePathSelectorOptional struct{}

func (ConfigMapEnvSourcePathSelectorOptional) FieldPath() *ConfigMapEnvSource_FieldTerminalPath {
	return &ConfigMapEnvSource_FieldTerminalPath{selector: ConfigMapEnvSource_FieldPathSelectorOptional}
}

func (s ConfigMapEnvSourcePathSelectorOptional) WithValue(value bool) *ConfigMapEnvSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapEnvSource_FieldTerminalPathValue)
}

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

type SecretEnvSourceFieldPathBuilder struct{}

func NewSecretEnvSourceFieldPathBuilder() SecretEnvSourceFieldPathBuilder {
	return SecretEnvSourceFieldPathBuilder{}
}
func (SecretEnvSourceFieldPathBuilder) Name() SecretEnvSourcePathSelectorName {
	return SecretEnvSourcePathSelectorName{}
}
func (SecretEnvSourceFieldPathBuilder) Optional() SecretEnvSourcePathSelectorOptional {
	return SecretEnvSourcePathSelectorOptional{}
}

type SecretEnvSourcePathSelectorName struct{}

func (SecretEnvSourcePathSelectorName) FieldPath() *SecretEnvSource_FieldTerminalPath {
	return &SecretEnvSource_FieldTerminalPath{selector: SecretEnvSource_FieldPathSelectorName}
}

func (s SecretEnvSourcePathSelectorName) WithValue(value string) *SecretEnvSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretEnvSource_FieldTerminalPathValue)
}

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

type SecretEnvSourcePathSelectorOptional struct{}

func (SecretEnvSourcePathSelectorOptional) FieldPath() *SecretEnvSource_FieldTerminalPath {
	return &SecretEnvSource_FieldTerminalPath{selector: SecretEnvSource_FieldPathSelectorOptional}
}

func (s SecretEnvSourcePathSelectorOptional) WithValue(value bool) *SecretEnvSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretEnvSource_FieldTerminalPathValue)
}

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

type EnvVarSourceFieldPathBuilder struct{}

func NewEnvVarSourceFieldPathBuilder() EnvVarSourceFieldPathBuilder {
	return EnvVarSourceFieldPathBuilder{}
}
func (EnvVarSourceFieldPathBuilder) ConfigMapKeyRef() EnvVarSourcePathSelectorConfigMapKeyRef {
	return EnvVarSourcePathSelectorConfigMapKeyRef{}
}
func (EnvVarSourceFieldPathBuilder) SecretKeyRef() EnvVarSourcePathSelectorSecretKeyRef {
	return EnvVarSourcePathSelectorSecretKeyRef{}
}

type EnvVarSourcePathSelectorConfigMapKeyRef struct{}

func (EnvVarSourcePathSelectorConfigMapKeyRef) FieldPath() *EnvVarSource_FieldTerminalPath {
	return &EnvVarSource_FieldTerminalPath{selector: EnvVarSource_FieldPathSelectorConfigMapKeyRef}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRef) WithValue(value *ConfigMapKeySelector) *EnvVarSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldTerminalPathValue)
}

func (s EnvVarSourcePathSelectorConfigMapKeyRef) WithArrayOfValues(values []*ConfigMapKeySelector) *EnvVarSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvVarSource_FieldTerminalPathArrayOfValues)
}

func (EnvVarSourcePathSelectorConfigMapKeyRef) WithSubPath(subPath ConfigMapKeySelector_FieldPath) *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{selector: EnvVarSource_FieldPathSelectorConfigMapKeyRef, subPath: subPath}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRef) WithSubValue(subPathValue ConfigMapKeySelector_FieldPathValue) *EnvVarSource_FieldSubPathValue {
	return &EnvVarSource_FieldSubPathValue{EnvVarSource_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRef) WithSubArrayOfValues(subPathArrayOfValues ConfigMapKeySelector_FieldPathArrayOfValues) *EnvVarSource_FieldSubPathArrayOfValues {
	return &EnvVarSource_FieldSubPathArrayOfValues{EnvVarSource_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRef) WithSubArrayItemValue(subPathArrayItemValue ConfigMapKeySelector_FieldPathArrayItemValue) *EnvVarSource_FieldSubPathArrayItemValue {
	return &EnvVarSource_FieldSubPathArrayItemValue{EnvVarSource_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (EnvVarSourcePathSelectorConfigMapKeyRef) Name() EnvVarSourcePathSelectorConfigMapKeyRefName {
	return EnvVarSourcePathSelectorConfigMapKeyRefName{}
}

func (EnvVarSourcePathSelectorConfigMapKeyRef) Key() EnvVarSourcePathSelectorConfigMapKeyRefKey {
	return EnvVarSourcePathSelectorConfigMapKeyRefKey{}
}

func (EnvVarSourcePathSelectorConfigMapKeyRef) Optional() EnvVarSourcePathSelectorConfigMapKeyRefOptional {
	return EnvVarSourcePathSelectorConfigMapKeyRefOptional{}
}

type EnvVarSourcePathSelectorConfigMapKeyRefName struct{}

func (EnvVarSourcePathSelectorConfigMapKeyRefName) FieldPath() *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{
		selector: EnvVarSource_FieldPathSelectorConfigMapKeyRef,
		subPath:  NewConfigMapKeySelectorFieldPathBuilder().Name().FieldPath(),
	}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRefName) WithValue(value string) *EnvVarSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldSubPathValue)
}

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

type EnvVarSourcePathSelectorConfigMapKeyRefKey struct{}

func (EnvVarSourcePathSelectorConfigMapKeyRefKey) FieldPath() *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{
		selector: EnvVarSource_FieldPathSelectorConfigMapKeyRef,
		subPath:  NewConfigMapKeySelectorFieldPathBuilder().Key().FieldPath(),
	}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRefKey) WithValue(value string) *EnvVarSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldSubPathValue)
}

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

type EnvVarSourcePathSelectorConfigMapKeyRefOptional struct{}

func (EnvVarSourcePathSelectorConfigMapKeyRefOptional) FieldPath() *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{
		selector: EnvVarSource_FieldPathSelectorConfigMapKeyRef,
		subPath:  NewConfigMapKeySelectorFieldPathBuilder().Optional().FieldPath(),
	}
}

func (s EnvVarSourcePathSelectorConfigMapKeyRefOptional) WithValue(value bool) *EnvVarSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldSubPathValue)
}

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

type EnvVarSourcePathSelectorSecretKeyRef struct{}

func (EnvVarSourcePathSelectorSecretKeyRef) FieldPath() *EnvVarSource_FieldTerminalPath {
	return &EnvVarSource_FieldTerminalPath{selector: EnvVarSource_FieldPathSelectorSecretKeyRef}
}

func (s EnvVarSourcePathSelectorSecretKeyRef) WithValue(value *SecretKeySelector) *EnvVarSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldTerminalPathValue)
}

func (s EnvVarSourcePathSelectorSecretKeyRef) WithArrayOfValues(values []*SecretKeySelector) *EnvVarSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*EnvVarSource_FieldTerminalPathArrayOfValues)
}

func (EnvVarSourcePathSelectorSecretKeyRef) WithSubPath(subPath SecretKeySelector_FieldPath) *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{selector: EnvVarSource_FieldPathSelectorSecretKeyRef, subPath: subPath}
}

func (s EnvVarSourcePathSelectorSecretKeyRef) WithSubValue(subPathValue SecretKeySelector_FieldPathValue) *EnvVarSource_FieldSubPathValue {
	return &EnvVarSource_FieldSubPathValue{EnvVarSource_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s EnvVarSourcePathSelectorSecretKeyRef) WithSubArrayOfValues(subPathArrayOfValues SecretKeySelector_FieldPathArrayOfValues) *EnvVarSource_FieldSubPathArrayOfValues {
	return &EnvVarSource_FieldSubPathArrayOfValues{EnvVarSource_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s EnvVarSourcePathSelectorSecretKeyRef) WithSubArrayItemValue(subPathArrayItemValue SecretKeySelector_FieldPathArrayItemValue) *EnvVarSource_FieldSubPathArrayItemValue {
	return &EnvVarSource_FieldSubPathArrayItemValue{EnvVarSource_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (EnvVarSourcePathSelectorSecretKeyRef) Name() EnvVarSourcePathSelectorSecretKeyRefName {
	return EnvVarSourcePathSelectorSecretKeyRefName{}
}

func (EnvVarSourcePathSelectorSecretKeyRef) Key() EnvVarSourcePathSelectorSecretKeyRefKey {
	return EnvVarSourcePathSelectorSecretKeyRefKey{}
}

func (EnvVarSourcePathSelectorSecretKeyRef) Optional() EnvVarSourcePathSelectorSecretKeyRefOptional {
	return EnvVarSourcePathSelectorSecretKeyRefOptional{}
}

type EnvVarSourcePathSelectorSecretKeyRefName struct{}

func (EnvVarSourcePathSelectorSecretKeyRefName) FieldPath() *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{
		selector: EnvVarSource_FieldPathSelectorSecretKeyRef,
		subPath:  NewSecretKeySelectorFieldPathBuilder().Name().FieldPath(),
	}
}

func (s EnvVarSourcePathSelectorSecretKeyRefName) WithValue(value string) *EnvVarSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldSubPathValue)
}

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

type EnvVarSourcePathSelectorSecretKeyRefKey struct{}

func (EnvVarSourcePathSelectorSecretKeyRefKey) FieldPath() *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{
		selector: EnvVarSource_FieldPathSelectorSecretKeyRef,
		subPath:  NewSecretKeySelectorFieldPathBuilder().Key().FieldPath(),
	}
}

func (s EnvVarSourcePathSelectorSecretKeyRefKey) WithValue(value string) *EnvVarSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldSubPathValue)
}

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

type EnvVarSourcePathSelectorSecretKeyRefOptional struct{}

func (EnvVarSourcePathSelectorSecretKeyRefOptional) FieldPath() *EnvVarSource_FieldSubPath {
	return &EnvVarSource_FieldSubPath{
		selector: EnvVarSource_FieldPathSelectorSecretKeyRef,
		subPath:  NewSecretKeySelectorFieldPathBuilder().Optional().FieldPath(),
	}
}

func (s EnvVarSourcePathSelectorSecretKeyRefOptional) WithValue(value bool) *EnvVarSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*EnvVarSource_FieldSubPathValue)
}

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

type ConfigMapKeySelectorFieldPathBuilder struct{}

func NewConfigMapKeySelectorFieldPathBuilder() ConfigMapKeySelectorFieldPathBuilder {
	return ConfigMapKeySelectorFieldPathBuilder{}
}
func (ConfigMapKeySelectorFieldPathBuilder) Name() ConfigMapKeySelectorPathSelectorName {
	return ConfigMapKeySelectorPathSelectorName{}
}
func (ConfigMapKeySelectorFieldPathBuilder) Key() ConfigMapKeySelectorPathSelectorKey {
	return ConfigMapKeySelectorPathSelectorKey{}
}
func (ConfigMapKeySelectorFieldPathBuilder) Optional() ConfigMapKeySelectorPathSelectorOptional {
	return ConfigMapKeySelectorPathSelectorOptional{}
}

type ConfigMapKeySelectorPathSelectorName struct{}

func (ConfigMapKeySelectorPathSelectorName) FieldPath() *ConfigMapKeySelector_FieldTerminalPath {
	return &ConfigMapKeySelector_FieldTerminalPath{selector: ConfigMapKeySelector_FieldPathSelectorName}
}

func (s ConfigMapKeySelectorPathSelectorName) WithValue(value string) *ConfigMapKeySelector_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapKeySelector_FieldTerminalPathValue)
}

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

type ConfigMapKeySelectorPathSelectorKey struct{}

func (ConfigMapKeySelectorPathSelectorKey) FieldPath() *ConfigMapKeySelector_FieldTerminalPath {
	return &ConfigMapKeySelector_FieldTerminalPath{selector: ConfigMapKeySelector_FieldPathSelectorKey}
}

func (s ConfigMapKeySelectorPathSelectorKey) WithValue(value string) *ConfigMapKeySelector_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapKeySelector_FieldTerminalPathValue)
}

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

type ConfigMapKeySelectorPathSelectorOptional struct{}

func (ConfigMapKeySelectorPathSelectorOptional) FieldPath() *ConfigMapKeySelector_FieldTerminalPath {
	return &ConfigMapKeySelector_FieldTerminalPath{selector: ConfigMapKeySelector_FieldPathSelectorOptional}
}

func (s ConfigMapKeySelectorPathSelectorOptional) WithValue(value bool) *ConfigMapKeySelector_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapKeySelector_FieldTerminalPathValue)
}

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

type SecretKeySelectorFieldPathBuilder struct{}

func NewSecretKeySelectorFieldPathBuilder() SecretKeySelectorFieldPathBuilder {
	return SecretKeySelectorFieldPathBuilder{}
}
func (SecretKeySelectorFieldPathBuilder) Name() SecretKeySelectorPathSelectorName {
	return SecretKeySelectorPathSelectorName{}
}
func (SecretKeySelectorFieldPathBuilder) Key() SecretKeySelectorPathSelectorKey {
	return SecretKeySelectorPathSelectorKey{}
}
func (SecretKeySelectorFieldPathBuilder) Optional() SecretKeySelectorPathSelectorOptional {
	return SecretKeySelectorPathSelectorOptional{}
}

type SecretKeySelectorPathSelectorName struct{}

func (SecretKeySelectorPathSelectorName) FieldPath() *SecretKeySelector_FieldTerminalPath {
	return &SecretKeySelector_FieldTerminalPath{selector: SecretKeySelector_FieldPathSelectorName}
}

func (s SecretKeySelectorPathSelectorName) WithValue(value string) *SecretKeySelector_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretKeySelector_FieldTerminalPathValue)
}

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

type SecretKeySelectorPathSelectorKey struct{}

func (SecretKeySelectorPathSelectorKey) FieldPath() *SecretKeySelector_FieldTerminalPath {
	return &SecretKeySelector_FieldTerminalPath{selector: SecretKeySelector_FieldPathSelectorKey}
}

func (s SecretKeySelectorPathSelectorKey) WithValue(value string) *SecretKeySelector_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretKeySelector_FieldTerminalPathValue)
}

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

type SecretKeySelectorPathSelectorOptional struct{}

func (SecretKeySelectorPathSelectorOptional) FieldPath() *SecretKeySelector_FieldTerminalPath {
	return &SecretKeySelector_FieldTerminalPath{selector: SecretKeySelector_FieldPathSelectorOptional}
}

func (s SecretKeySelectorPathSelectorOptional) WithValue(value bool) *SecretKeySelector_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretKeySelector_FieldTerminalPathValue)
}

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

type LocalObjectReferenceSecretFieldPathBuilder struct{}

func NewLocalObjectReferenceSecretFieldPathBuilder() LocalObjectReferenceSecretFieldPathBuilder {
	return LocalObjectReferenceSecretFieldPathBuilder{}
}
func (LocalObjectReferenceSecretFieldPathBuilder) Name() LocalObjectReferenceSecretPathSelectorName {
	return LocalObjectReferenceSecretPathSelectorName{}
}

type LocalObjectReferenceSecretPathSelectorName struct{}

func (LocalObjectReferenceSecretPathSelectorName) FieldPath() *LocalObjectReferenceSecret_FieldTerminalPath {
	return &LocalObjectReferenceSecret_FieldTerminalPath{selector: LocalObjectReferenceSecret_FieldPathSelectorName}
}

func (s LocalObjectReferenceSecretPathSelectorName) WithValue(value *secrets_secret.Reference) *LocalObjectReferenceSecret_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*LocalObjectReferenceSecret_FieldTerminalPathValue)
}

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

type SecurityContextFieldPathBuilder struct{}

func NewSecurityContextFieldPathBuilder() SecurityContextFieldPathBuilder {
	return SecurityContextFieldPathBuilder{}
}
func (SecurityContextFieldPathBuilder) Privileged() SecurityContextPathSelectorPrivileged {
	return SecurityContextPathSelectorPrivileged{}
}

type SecurityContextPathSelectorPrivileged struct{}

func (SecurityContextPathSelectorPrivileged) FieldPath() *SecurityContext_FieldTerminalPath {
	return &SecurityContext_FieldTerminalPath{selector: SecurityContext_FieldPathSelectorPrivileged}
}

func (s SecurityContextPathSelectorPrivileged) WithValue(value bool) *SecurityContext_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecurityContext_FieldTerminalPathValue)
}

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

type VolumeFieldPathBuilder struct{}

func NewVolumeFieldPathBuilder() VolumeFieldPathBuilder {
	return VolumeFieldPathBuilder{}
}
func (VolumeFieldPathBuilder) Name() VolumePathSelectorName {
	return VolumePathSelectorName{}
}
func (VolumeFieldPathBuilder) HostPath() VolumePathSelectorHostPath {
	return VolumePathSelectorHostPath{}
}
func (VolumeFieldPathBuilder) Secret() VolumePathSelectorSecret {
	return VolumePathSelectorSecret{}
}
func (VolumeFieldPathBuilder) ConfigMap() VolumePathSelectorConfigMap {
	return VolumePathSelectorConfigMap{}
}

type VolumePathSelectorName struct{}

func (VolumePathSelectorName) FieldPath() *Volume_FieldTerminalPath {
	return &Volume_FieldTerminalPath{selector: Volume_FieldPathSelectorName}
}

func (s VolumePathSelectorName) WithValue(value string) *Volume_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldTerminalPathValue)
}

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

type VolumePathSelectorHostPath struct{}

func (VolumePathSelectorHostPath) FieldPath() *Volume_FieldTerminalPath {
	return &Volume_FieldTerminalPath{selector: Volume_FieldPathSelectorHostPath}
}

func (s VolumePathSelectorHostPath) WithValue(value *HostPathVolumeSource) *Volume_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldTerminalPathValue)
}

func (s VolumePathSelectorHostPath) WithArrayOfValues(values []*HostPathVolumeSource) *Volume_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Volume_FieldTerminalPathArrayOfValues)
}

func (VolumePathSelectorHostPath) WithSubPath(subPath HostPathVolumeSource_FieldPath) *Volume_FieldSubPath {
	return &Volume_FieldSubPath{selector: Volume_FieldPathSelectorHostPath, subPath: subPath}
}

func (s VolumePathSelectorHostPath) WithSubValue(subPathValue HostPathVolumeSource_FieldPathValue) *Volume_FieldSubPathValue {
	return &Volume_FieldSubPathValue{Volume_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s VolumePathSelectorHostPath) WithSubArrayOfValues(subPathArrayOfValues HostPathVolumeSource_FieldPathArrayOfValues) *Volume_FieldSubPathArrayOfValues {
	return &Volume_FieldSubPathArrayOfValues{Volume_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s VolumePathSelectorHostPath) WithSubArrayItemValue(subPathArrayItemValue HostPathVolumeSource_FieldPathArrayItemValue) *Volume_FieldSubPathArrayItemValue {
	return &Volume_FieldSubPathArrayItemValue{Volume_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (VolumePathSelectorHostPath) Path() VolumePathSelectorHostPathPath {
	return VolumePathSelectorHostPathPath{}
}

func (VolumePathSelectorHostPath) Type() VolumePathSelectorHostPathType {
	return VolumePathSelectorHostPathType{}
}

type VolumePathSelectorHostPathPath struct{}

func (VolumePathSelectorHostPathPath) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorHostPath,
		subPath:  NewHostPathVolumeSourceFieldPathBuilder().Path().FieldPath(),
	}
}

func (s VolumePathSelectorHostPathPath) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorHostPathType struct{}

func (VolumePathSelectorHostPathType) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorHostPath,
		subPath:  NewHostPathVolumeSourceFieldPathBuilder().Type().FieldPath(),
	}
}

func (s VolumePathSelectorHostPathType) WithValue(value HostPathVolumeSource_Type) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

func (s VolumePathSelectorHostPathType) WithArrayOfValues(values []HostPathVolumeSource_Type) *Volume_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Volume_FieldSubPathArrayOfValues)
}

type VolumePathSelectorSecret struct{}

func (VolumePathSelectorSecret) FieldPath() *Volume_FieldTerminalPath {
	return &Volume_FieldTerminalPath{selector: Volume_FieldPathSelectorSecret}
}

func (s VolumePathSelectorSecret) WithValue(value *SecretVolumeSource) *Volume_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldTerminalPathValue)
}

func (s VolumePathSelectorSecret) WithArrayOfValues(values []*SecretVolumeSource) *Volume_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Volume_FieldTerminalPathArrayOfValues)
}

func (VolumePathSelectorSecret) WithSubPath(subPath SecretVolumeSource_FieldPath) *Volume_FieldSubPath {
	return &Volume_FieldSubPath{selector: Volume_FieldPathSelectorSecret, subPath: subPath}
}

func (s VolumePathSelectorSecret) WithSubValue(subPathValue SecretVolumeSource_FieldPathValue) *Volume_FieldSubPathValue {
	return &Volume_FieldSubPathValue{Volume_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s VolumePathSelectorSecret) WithSubArrayOfValues(subPathArrayOfValues SecretVolumeSource_FieldPathArrayOfValues) *Volume_FieldSubPathArrayOfValues {
	return &Volume_FieldSubPathArrayOfValues{Volume_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s VolumePathSelectorSecret) WithSubArrayItemValue(subPathArrayItemValue SecretVolumeSource_FieldPathArrayItemValue) *Volume_FieldSubPathArrayItemValue {
	return &Volume_FieldSubPathArrayItemValue{Volume_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (VolumePathSelectorSecret) SecretName() VolumePathSelectorSecretSecretName {
	return VolumePathSelectorSecretSecretName{}
}

func (VolumePathSelectorSecret) Items() VolumePathSelectorSecretItems {
	return VolumePathSelectorSecretItems{}
}

func (VolumePathSelectorSecret) DefaultMode() VolumePathSelectorSecretDefaultMode {
	return VolumePathSelectorSecretDefaultMode{}
}

func (VolumePathSelectorSecret) Optional() VolumePathSelectorSecretOptional {
	return VolumePathSelectorSecretOptional{}
}

type VolumePathSelectorSecretSecretName struct{}

func (VolumePathSelectorSecretSecretName) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().SecretName().FieldPath(),
	}
}

func (s VolumePathSelectorSecretSecretName) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorSecretItems struct{}

func (VolumePathSelectorSecretItems) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().Items().FieldPath(),
	}
}

func (s VolumePathSelectorSecretItems) WithValue(value []*KeyToPath) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

func (s VolumePathSelectorSecretItems) WithArrayOfValues(values [][]*KeyToPath) *Volume_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Volume_FieldSubPathArrayOfValues)
}

func (s VolumePathSelectorSecretItems) WithItemValue(value *KeyToPath) *Volume_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Volume_FieldSubPathArrayItemValue)
}

func (VolumePathSelectorSecretItems) Key() VolumePathSelectorSecretItemsKey {
	return VolumePathSelectorSecretItemsKey{}
}

func (VolumePathSelectorSecretItems) Path() VolumePathSelectorSecretItemsPath {
	return VolumePathSelectorSecretItemsPath{}
}

func (VolumePathSelectorSecretItems) Mode() VolumePathSelectorSecretItemsMode {
	return VolumePathSelectorSecretItemsMode{}
}

type VolumePathSelectorSecretItemsKey struct{}

func (VolumePathSelectorSecretItemsKey) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().Items().Key().FieldPath(),
	}
}

func (s VolumePathSelectorSecretItemsKey) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorSecretItemsPath struct{}

func (VolumePathSelectorSecretItemsPath) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().Items().Path().FieldPath(),
	}
}

func (s VolumePathSelectorSecretItemsPath) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorSecretItemsMode struct{}

func (VolumePathSelectorSecretItemsMode) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().Items().Mode().FieldPath(),
	}
}

func (s VolumePathSelectorSecretItemsMode) WithValue(value int32) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorSecretDefaultMode struct{}

func (VolumePathSelectorSecretDefaultMode) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().DefaultMode().FieldPath(),
	}
}

func (s VolumePathSelectorSecretDefaultMode) WithValue(value int32) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorSecretOptional struct{}

func (VolumePathSelectorSecretOptional) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorSecret,
		subPath:  NewSecretVolumeSourceFieldPathBuilder().Optional().FieldPath(),
	}
}

func (s VolumePathSelectorSecretOptional) WithValue(value bool) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorConfigMap struct{}

func (VolumePathSelectorConfigMap) FieldPath() *Volume_FieldTerminalPath {
	return &Volume_FieldTerminalPath{selector: Volume_FieldPathSelectorConfigMap}
}

func (s VolumePathSelectorConfigMap) WithValue(value *ConfigMapVolumeSource) *Volume_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldTerminalPathValue)
}

func (s VolumePathSelectorConfigMap) WithArrayOfValues(values []*ConfigMapVolumeSource) *Volume_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Volume_FieldTerminalPathArrayOfValues)
}

func (VolumePathSelectorConfigMap) WithSubPath(subPath ConfigMapVolumeSource_FieldPath) *Volume_FieldSubPath {
	return &Volume_FieldSubPath{selector: Volume_FieldPathSelectorConfigMap, subPath: subPath}
}

func (s VolumePathSelectorConfigMap) WithSubValue(subPathValue ConfigMapVolumeSource_FieldPathValue) *Volume_FieldSubPathValue {
	return &Volume_FieldSubPathValue{Volume_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s VolumePathSelectorConfigMap) WithSubArrayOfValues(subPathArrayOfValues ConfigMapVolumeSource_FieldPathArrayOfValues) *Volume_FieldSubPathArrayOfValues {
	return &Volume_FieldSubPathArrayOfValues{Volume_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s VolumePathSelectorConfigMap) WithSubArrayItemValue(subPathArrayItemValue ConfigMapVolumeSource_FieldPathArrayItemValue) *Volume_FieldSubPathArrayItemValue {
	return &Volume_FieldSubPathArrayItemValue{Volume_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (VolumePathSelectorConfigMap) Name() VolumePathSelectorConfigMapName {
	return VolumePathSelectorConfigMapName{}
}

func (VolumePathSelectorConfigMap) Items() VolumePathSelectorConfigMapItems {
	return VolumePathSelectorConfigMapItems{}
}

func (VolumePathSelectorConfigMap) DefaultMode() VolumePathSelectorConfigMapDefaultMode {
	return VolumePathSelectorConfigMapDefaultMode{}
}

func (VolumePathSelectorConfigMap) Optional() VolumePathSelectorConfigMapOptional {
	return VolumePathSelectorConfigMapOptional{}
}

type VolumePathSelectorConfigMapName struct{}

func (VolumePathSelectorConfigMapName) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().Name().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapName) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorConfigMapItems struct{}

func (VolumePathSelectorConfigMapItems) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().Items().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapItems) WithValue(value []*KeyToPath) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

func (s VolumePathSelectorConfigMapItems) WithArrayOfValues(values [][]*KeyToPath) *Volume_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Volume_FieldSubPathArrayOfValues)
}

func (s VolumePathSelectorConfigMapItems) WithItemValue(value *KeyToPath) *Volume_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Volume_FieldSubPathArrayItemValue)
}

func (VolumePathSelectorConfigMapItems) Key() VolumePathSelectorConfigMapItemsKey {
	return VolumePathSelectorConfigMapItemsKey{}
}

func (VolumePathSelectorConfigMapItems) Path() VolumePathSelectorConfigMapItemsPath {
	return VolumePathSelectorConfigMapItemsPath{}
}

func (VolumePathSelectorConfigMapItems) Mode() VolumePathSelectorConfigMapItemsMode {
	return VolumePathSelectorConfigMapItemsMode{}
}

type VolumePathSelectorConfigMapItemsKey struct{}

func (VolumePathSelectorConfigMapItemsKey) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().Items().Key().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapItemsKey) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorConfigMapItemsPath struct{}

func (VolumePathSelectorConfigMapItemsPath) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().Items().Path().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapItemsPath) WithValue(value string) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorConfigMapItemsMode struct{}

func (VolumePathSelectorConfigMapItemsMode) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().Items().Mode().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapItemsMode) WithValue(value int32) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorConfigMapDefaultMode struct{}

func (VolumePathSelectorConfigMapDefaultMode) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().DefaultMode().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapDefaultMode) WithValue(value int32) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumePathSelectorConfigMapOptional struct{}

func (VolumePathSelectorConfigMapOptional) FieldPath() *Volume_FieldSubPath {
	return &Volume_FieldSubPath{
		selector: Volume_FieldPathSelectorConfigMap,
		subPath:  NewConfigMapVolumeSourceFieldPathBuilder().Optional().FieldPath(),
	}
}

func (s VolumePathSelectorConfigMapOptional) WithValue(value bool) *Volume_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Volume_FieldSubPathValue)
}

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

type VolumeMountFieldPathBuilder struct{}

func NewVolumeMountFieldPathBuilder() VolumeMountFieldPathBuilder {
	return VolumeMountFieldPathBuilder{}
}
func (VolumeMountFieldPathBuilder) Name() VolumeMountPathSelectorName {
	return VolumeMountPathSelectorName{}
}
func (VolumeMountFieldPathBuilder) ReadOnly() VolumeMountPathSelectorReadOnly {
	return VolumeMountPathSelectorReadOnly{}
}
func (VolumeMountFieldPathBuilder) MountPath() VolumeMountPathSelectorMountPath {
	return VolumeMountPathSelectorMountPath{}
}
func (VolumeMountFieldPathBuilder) SubPath() VolumeMountPathSelectorSubPath {
	return VolumeMountPathSelectorSubPath{}
}

type VolumeMountPathSelectorName struct{}

func (VolumeMountPathSelectorName) FieldPath() *VolumeMount_FieldTerminalPath {
	return &VolumeMount_FieldTerminalPath{selector: VolumeMount_FieldPathSelectorName}
}

func (s VolumeMountPathSelectorName) WithValue(value string) *VolumeMount_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*VolumeMount_FieldTerminalPathValue)
}

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

type VolumeMountPathSelectorReadOnly struct{}

func (VolumeMountPathSelectorReadOnly) FieldPath() *VolumeMount_FieldTerminalPath {
	return &VolumeMount_FieldTerminalPath{selector: VolumeMount_FieldPathSelectorReadOnly}
}

func (s VolumeMountPathSelectorReadOnly) WithValue(value bool) *VolumeMount_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*VolumeMount_FieldTerminalPathValue)
}

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

type VolumeMountPathSelectorMountPath struct{}

func (VolumeMountPathSelectorMountPath) FieldPath() *VolumeMount_FieldTerminalPath {
	return &VolumeMount_FieldTerminalPath{selector: VolumeMount_FieldPathSelectorMountPath}
}

func (s VolumeMountPathSelectorMountPath) WithValue(value string) *VolumeMount_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*VolumeMount_FieldTerminalPathValue)
}

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

type VolumeMountPathSelectorSubPath struct{}

func (VolumeMountPathSelectorSubPath) FieldPath() *VolumeMount_FieldTerminalPath {
	return &VolumeMount_FieldTerminalPath{selector: VolumeMount_FieldPathSelectorSubPath}
}

func (s VolumeMountPathSelectorSubPath) WithValue(value string) *VolumeMount_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*VolumeMount_FieldTerminalPathValue)
}

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

type HostPathVolumeSourceFieldPathBuilder struct{}

func NewHostPathVolumeSourceFieldPathBuilder() HostPathVolumeSourceFieldPathBuilder {
	return HostPathVolumeSourceFieldPathBuilder{}
}
func (HostPathVolumeSourceFieldPathBuilder) Path() HostPathVolumeSourcePathSelectorPath {
	return HostPathVolumeSourcePathSelectorPath{}
}
func (HostPathVolumeSourceFieldPathBuilder) Type() HostPathVolumeSourcePathSelectorType {
	return HostPathVolumeSourcePathSelectorType{}
}

type HostPathVolumeSourcePathSelectorPath struct{}

func (HostPathVolumeSourcePathSelectorPath) FieldPath() *HostPathVolumeSource_FieldTerminalPath {
	return &HostPathVolumeSource_FieldTerminalPath{selector: HostPathVolumeSource_FieldPathSelectorPath}
}

func (s HostPathVolumeSourcePathSelectorPath) WithValue(value string) *HostPathVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*HostPathVolumeSource_FieldTerminalPathValue)
}

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

type HostPathVolumeSourcePathSelectorType struct{}

func (HostPathVolumeSourcePathSelectorType) FieldPath() *HostPathVolumeSource_FieldTerminalPath {
	return &HostPathVolumeSource_FieldTerminalPath{selector: HostPathVolumeSource_FieldPathSelectorType}
}

func (s HostPathVolumeSourcePathSelectorType) WithValue(value HostPathVolumeSource_Type) *HostPathVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*HostPathVolumeSource_FieldTerminalPathValue)
}

func (s HostPathVolumeSourcePathSelectorType) WithArrayOfValues(values []HostPathVolumeSource_Type) *HostPathVolumeSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*HostPathVolumeSource_FieldTerminalPathArrayOfValues)
}

type SecretVolumeSourceFieldPathBuilder struct{}

func NewSecretVolumeSourceFieldPathBuilder() SecretVolumeSourceFieldPathBuilder {
	return SecretVolumeSourceFieldPathBuilder{}
}
func (SecretVolumeSourceFieldPathBuilder) SecretName() SecretVolumeSourcePathSelectorSecretName {
	return SecretVolumeSourcePathSelectorSecretName{}
}
func (SecretVolumeSourceFieldPathBuilder) Items() SecretVolumeSourcePathSelectorItems {
	return SecretVolumeSourcePathSelectorItems{}
}
func (SecretVolumeSourceFieldPathBuilder) DefaultMode() SecretVolumeSourcePathSelectorDefaultMode {
	return SecretVolumeSourcePathSelectorDefaultMode{}
}
func (SecretVolumeSourceFieldPathBuilder) Optional() SecretVolumeSourcePathSelectorOptional {
	return SecretVolumeSourcePathSelectorOptional{}
}

type SecretVolumeSourcePathSelectorSecretName struct{}

func (SecretVolumeSourcePathSelectorSecretName) FieldPath() *SecretVolumeSource_FieldTerminalPath {
	return &SecretVolumeSource_FieldTerminalPath{selector: SecretVolumeSource_FieldPathSelectorSecretName}
}

func (s SecretVolumeSourcePathSelectorSecretName) WithValue(value string) *SecretVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldTerminalPathValue)
}

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

type SecretVolumeSourcePathSelectorItems struct{}

func (SecretVolumeSourcePathSelectorItems) FieldPath() *SecretVolumeSource_FieldTerminalPath {
	return &SecretVolumeSource_FieldTerminalPath{selector: SecretVolumeSource_FieldPathSelectorItems}
}

func (s SecretVolumeSourcePathSelectorItems) WithValue(value []*KeyToPath) *SecretVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldTerminalPathValue)
}

func (s SecretVolumeSourcePathSelectorItems) WithArrayOfValues(values [][]*KeyToPath) *SecretVolumeSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SecretVolumeSource_FieldTerminalPathArrayOfValues)
}

func (s SecretVolumeSourcePathSelectorItems) WithItemValue(value *KeyToPath) *SecretVolumeSource_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*SecretVolumeSource_FieldTerminalPathArrayItemValue)
}
func (SecretVolumeSourcePathSelectorItems) WithSubPath(subPath KeyToPath_FieldPath) *SecretVolumeSource_FieldSubPath {
	return &SecretVolumeSource_FieldSubPath{selector: SecretVolumeSource_FieldPathSelectorItems, subPath: subPath}
}

func (s SecretVolumeSourcePathSelectorItems) WithSubValue(subPathValue KeyToPath_FieldPathValue) *SecretVolumeSource_FieldSubPathValue {
	return &SecretVolumeSource_FieldSubPathValue{SecretVolumeSource_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s SecretVolumeSourcePathSelectorItems) WithSubArrayOfValues(subPathArrayOfValues KeyToPath_FieldPathArrayOfValues) *SecretVolumeSource_FieldSubPathArrayOfValues {
	return &SecretVolumeSource_FieldSubPathArrayOfValues{SecretVolumeSource_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s SecretVolumeSourcePathSelectorItems) WithSubArrayItemValue(subPathArrayItemValue KeyToPath_FieldPathArrayItemValue) *SecretVolumeSource_FieldSubPathArrayItemValue {
	return &SecretVolumeSource_FieldSubPathArrayItemValue{SecretVolumeSource_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (SecretVolumeSourcePathSelectorItems) Key() SecretVolumeSourcePathSelectorItemsKey {
	return SecretVolumeSourcePathSelectorItemsKey{}
}

func (SecretVolumeSourcePathSelectorItems) Path() SecretVolumeSourcePathSelectorItemsPath {
	return SecretVolumeSourcePathSelectorItemsPath{}
}

func (SecretVolumeSourcePathSelectorItems) Mode() SecretVolumeSourcePathSelectorItemsMode {
	return SecretVolumeSourcePathSelectorItemsMode{}
}

type SecretVolumeSourcePathSelectorItemsKey struct{}

func (SecretVolumeSourcePathSelectorItemsKey) FieldPath() *SecretVolumeSource_FieldSubPath {
	return &SecretVolumeSource_FieldSubPath{
		selector: SecretVolumeSource_FieldPathSelectorItems,
		subPath:  NewKeyToPathFieldPathBuilder().Key().FieldPath(),
	}
}

func (s SecretVolumeSourcePathSelectorItemsKey) WithValue(value string) *SecretVolumeSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldSubPathValue)
}

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

type SecretVolumeSourcePathSelectorItemsPath struct{}

func (SecretVolumeSourcePathSelectorItemsPath) FieldPath() *SecretVolumeSource_FieldSubPath {
	return &SecretVolumeSource_FieldSubPath{
		selector: SecretVolumeSource_FieldPathSelectorItems,
		subPath:  NewKeyToPathFieldPathBuilder().Path().FieldPath(),
	}
}

func (s SecretVolumeSourcePathSelectorItemsPath) WithValue(value string) *SecretVolumeSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldSubPathValue)
}

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

type SecretVolumeSourcePathSelectorItemsMode struct{}

func (SecretVolumeSourcePathSelectorItemsMode) FieldPath() *SecretVolumeSource_FieldSubPath {
	return &SecretVolumeSource_FieldSubPath{
		selector: SecretVolumeSource_FieldPathSelectorItems,
		subPath:  NewKeyToPathFieldPathBuilder().Mode().FieldPath(),
	}
}

func (s SecretVolumeSourcePathSelectorItemsMode) WithValue(value int32) *SecretVolumeSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldSubPathValue)
}

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

type SecretVolumeSourcePathSelectorDefaultMode struct{}

func (SecretVolumeSourcePathSelectorDefaultMode) FieldPath() *SecretVolumeSource_FieldTerminalPath {
	return &SecretVolumeSource_FieldTerminalPath{selector: SecretVolumeSource_FieldPathSelectorDefaultMode}
}

func (s SecretVolumeSourcePathSelectorDefaultMode) WithValue(value int32) *SecretVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldTerminalPathValue)
}

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

type SecretVolumeSourcePathSelectorOptional struct{}

func (SecretVolumeSourcePathSelectorOptional) FieldPath() *SecretVolumeSource_FieldTerminalPath {
	return &SecretVolumeSource_FieldTerminalPath{selector: SecretVolumeSource_FieldPathSelectorOptional}
}

func (s SecretVolumeSourcePathSelectorOptional) WithValue(value bool) *SecretVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SecretVolumeSource_FieldTerminalPathValue)
}

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

type KeyToPathFieldPathBuilder struct{}

func NewKeyToPathFieldPathBuilder() KeyToPathFieldPathBuilder {
	return KeyToPathFieldPathBuilder{}
}
func (KeyToPathFieldPathBuilder) Key() KeyToPathPathSelectorKey {
	return KeyToPathPathSelectorKey{}
}
func (KeyToPathFieldPathBuilder) Path() KeyToPathPathSelectorPath {
	return KeyToPathPathSelectorPath{}
}
func (KeyToPathFieldPathBuilder) Mode() KeyToPathPathSelectorMode {
	return KeyToPathPathSelectorMode{}
}

type KeyToPathPathSelectorKey struct{}

func (KeyToPathPathSelectorKey) FieldPath() *KeyToPath_FieldTerminalPath {
	return &KeyToPath_FieldTerminalPath{selector: KeyToPath_FieldPathSelectorKey}
}

func (s KeyToPathPathSelectorKey) WithValue(value string) *KeyToPath_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*KeyToPath_FieldTerminalPathValue)
}

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

type KeyToPathPathSelectorPath struct{}

func (KeyToPathPathSelectorPath) FieldPath() *KeyToPath_FieldTerminalPath {
	return &KeyToPath_FieldTerminalPath{selector: KeyToPath_FieldPathSelectorPath}
}

func (s KeyToPathPathSelectorPath) WithValue(value string) *KeyToPath_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*KeyToPath_FieldTerminalPathValue)
}

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

type KeyToPathPathSelectorMode struct{}

func (KeyToPathPathSelectorMode) FieldPath() *KeyToPath_FieldTerminalPath {
	return &KeyToPath_FieldTerminalPath{selector: KeyToPath_FieldPathSelectorMode}
}

func (s KeyToPathPathSelectorMode) WithValue(value int32) *KeyToPath_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*KeyToPath_FieldTerminalPathValue)
}

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

type ConfigMapVolumeSourceFieldPathBuilder struct{}

func NewConfigMapVolumeSourceFieldPathBuilder() ConfigMapVolumeSourceFieldPathBuilder {
	return ConfigMapVolumeSourceFieldPathBuilder{}
}
func (ConfigMapVolumeSourceFieldPathBuilder) Name() ConfigMapVolumeSourcePathSelectorName {
	return ConfigMapVolumeSourcePathSelectorName{}
}
func (ConfigMapVolumeSourceFieldPathBuilder) Items() ConfigMapVolumeSourcePathSelectorItems {
	return ConfigMapVolumeSourcePathSelectorItems{}
}
func (ConfigMapVolumeSourceFieldPathBuilder) DefaultMode() ConfigMapVolumeSourcePathSelectorDefaultMode {
	return ConfigMapVolumeSourcePathSelectorDefaultMode{}
}
func (ConfigMapVolumeSourceFieldPathBuilder) Optional() ConfigMapVolumeSourcePathSelectorOptional {
	return ConfigMapVolumeSourcePathSelectorOptional{}
}

type ConfigMapVolumeSourcePathSelectorName struct{}

func (ConfigMapVolumeSourcePathSelectorName) FieldPath() *ConfigMapVolumeSource_FieldTerminalPath {
	return &ConfigMapVolumeSource_FieldTerminalPath{selector: ConfigMapVolumeSource_FieldPathSelectorName}
}

func (s ConfigMapVolumeSourcePathSelectorName) WithValue(value string) *ConfigMapVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldTerminalPathValue)
}

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

type ConfigMapVolumeSourcePathSelectorItems struct{}

func (ConfigMapVolumeSourcePathSelectorItems) FieldPath() *ConfigMapVolumeSource_FieldTerminalPath {
	return &ConfigMapVolumeSource_FieldTerminalPath{selector: ConfigMapVolumeSource_FieldPathSelectorItems}
}

func (s ConfigMapVolumeSourcePathSelectorItems) WithValue(value []*KeyToPath) *ConfigMapVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldTerminalPathValue)
}

func (s ConfigMapVolumeSourcePathSelectorItems) WithArrayOfValues(values [][]*KeyToPath) *ConfigMapVolumeSource_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*ConfigMapVolumeSource_FieldTerminalPathArrayOfValues)
}

func (s ConfigMapVolumeSourcePathSelectorItems) WithItemValue(value *KeyToPath) *ConfigMapVolumeSource_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*ConfigMapVolumeSource_FieldTerminalPathArrayItemValue)
}
func (ConfigMapVolumeSourcePathSelectorItems) WithSubPath(subPath KeyToPath_FieldPath) *ConfigMapVolumeSource_FieldSubPath {
	return &ConfigMapVolumeSource_FieldSubPath{selector: ConfigMapVolumeSource_FieldPathSelectorItems, subPath: subPath}
}

func (s ConfigMapVolumeSourcePathSelectorItems) WithSubValue(subPathValue KeyToPath_FieldPathValue) *ConfigMapVolumeSource_FieldSubPathValue {
	return &ConfigMapVolumeSource_FieldSubPathValue{ConfigMapVolumeSource_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s ConfigMapVolumeSourcePathSelectorItems) WithSubArrayOfValues(subPathArrayOfValues KeyToPath_FieldPathArrayOfValues) *ConfigMapVolumeSource_FieldSubPathArrayOfValues {
	return &ConfigMapVolumeSource_FieldSubPathArrayOfValues{ConfigMapVolumeSource_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s ConfigMapVolumeSourcePathSelectorItems) WithSubArrayItemValue(subPathArrayItemValue KeyToPath_FieldPathArrayItemValue) *ConfigMapVolumeSource_FieldSubPathArrayItemValue {
	return &ConfigMapVolumeSource_FieldSubPathArrayItemValue{ConfigMapVolumeSource_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (ConfigMapVolumeSourcePathSelectorItems) Key() ConfigMapVolumeSourcePathSelectorItemsKey {
	return ConfigMapVolumeSourcePathSelectorItemsKey{}
}

func (ConfigMapVolumeSourcePathSelectorItems) Path() ConfigMapVolumeSourcePathSelectorItemsPath {
	return ConfigMapVolumeSourcePathSelectorItemsPath{}
}

func (ConfigMapVolumeSourcePathSelectorItems) Mode() ConfigMapVolumeSourcePathSelectorItemsMode {
	return ConfigMapVolumeSourcePathSelectorItemsMode{}
}

type ConfigMapVolumeSourcePathSelectorItemsKey struct{}

func (ConfigMapVolumeSourcePathSelectorItemsKey) FieldPath() *ConfigMapVolumeSource_FieldSubPath {
	return &ConfigMapVolumeSource_FieldSubPath{
		selector: ConfigMapVolumeSource_FieldPathSelectorItems,
		subPath:  NewKeyToPathFieldPathBuilder().Key().FieldPath(),
	}
}

func (s ConfigMapVolumeSourcePathSelectorItemsKey) WithValue(value string) *ConfigMapVolumeSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldSubPathValue)
}

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

type ConfigMapVolumeSourcePathSelectorItemsPath struct{}

func (ConfigMapVolumeSourcePathSelectorItemsPath) FieldPath() *ConfigMapVolumeSource_FieldSubPath {
	return &ConfigMapVolumeSource_FieldSubPath{
		selector: ConfigMapVolumeSource_FieldPathSelectorItems,
		subPath:  NewKeyToPathFieldPathBuilder().Path().FieldPath(),
	}
}

func (s ConfigMapVolumeSourcePathSelectorItemsPath) WithValue(value string) *ConfigMapVolumeSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldSubPathValue)
}

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

type ConfigMapVolumeSourcePathSelectorItemsMode struct{}

func (ConfigMapVolumeSourcePathSelectorItemsMode) FieldPath() *ConfigMapVolumeSource_FieldSubPath {
	return &ConfigMapVolumeSource_FieldSubPath{
		selector: ConfigMapVolumeSource_FieldPathSelectorItems,
		subPath:  NewKeyToPathFieldPathBuilder().Mode().FieldPath(),
	}
}

func (s ConfigMapVolumeSourcePathSelectorItemsMode) WithValue(value int32) *ConfigMapVolumeSource_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldSubPathValue)
}

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

type ConfigMapVolumeSourcePathSelectorDefaultMode struct{}

func (ConfigMapVolumeSourcePathSelectorDefaultMode) FieldPath() *ConfigMapVolumeSource_FieldTerminalPath {
	return &ConfigMapVolumeSource_FieldTerminalPath{selector: ConfigMapVolumeSource_FieldPathSelectorDefaultMode}
}

func (s ConfigMapVolumeSourcePathSelectorDefaultMode) WithValue(value int32) *ConfigMapVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldTerminalPathValue)
}

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

type ConfigMapVolumeSourcePathSelectorOptional struct{}

func (ConfigMapVolumeSourcePathSelectorOptional) FieldPath() *ConfigMapVolumeSource_FieldTerminalPath {
	return &ConfigMapVolumeSource_FieldTerminalPath{selector: ConfigMapVolumeSource_FieldPathSelectorOptional}
}

func (s ConfigMapVolumeSourcePathSelectorOptional) WithValue(value bool) *ConfigMapVolumeSource_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*ConfigMapVolumeSource_FieldTerminalPathValue)
}

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