github.com/cloudwan/edgelq-sdk@v1.15.4/secrets/resources/v1/crypto_key/crypto_key.pb.fieldpathbuilder.go

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

package crypto_key

// proto imports
import (
	project "github.com/cloudwan/edgelq-sdk/secrets/resources/v1/project"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// make sure we're using proto imports
var (
	_ = &project.Project{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type CryptoKeyFieldPathBuilder struct{}

func NewCryptoKeyFieldPathBuilder() CryptoKeyFieldPathBuilder {
	return CryptoKeyFieldPathBuilder{}
}
func (CryptoKeyFieldPathBuilder) Name() CryptoKeyPathSelectorName {
	return CryptoKeyPathSelectorName{}
}
func (CryptoKeyFieldPathBuilder) Metadata() CryptoKeyPathSelectorMetadata {
	return CryptoKeyPathSelectorMetadata{}
}
func (CryptoKeyFieldPathBuilder) Key() CryptoKeyPathSelectorKey {
	return CryptoKeyPathSelectorKey{}
}

type CryptoKeyPathSelectorName struct{}

func (CryptoKeyPathSelectorName) FieldPath() *CryptoKey_FieldTerminalPath {
	return &CryptoKey_FieldTerminalPath{selector: CryptoKey_FieldPathSelectorName}
}

func (s CryptoKeyPathSelectorName) WithValue(value *Name) *CryptoKey_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldTerminalPathValue)
}

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

type CryptoKeyPathSelectorMetadata struct{}

func (CryptoKeyPathSelectorMetadata) FieldPath() *CryptoKey_FieldTerminalPath {
	return &CryptoKey_FieldTerminalPath{selector: CryptoKey_FieldPathSelectorMetadata}
}

func (s CryptoKeyPathSelectorMetadata) WithValue(value *meta.Meta) *CryptoKey_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldTerminalPathValue)
}

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

func (CryptoKeyPathSelectorMetadata) WithSubPath(subPath meta.Meta_FieldPath) *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{selector: CryptoKey_FieldPathSelectorMetadata, subPath: subPath}
}

func (s CryptoKeyPathSelectorMetadata) WithSubValue(subPathValue meta.Meta_FieldPathValue) *CryptoKey_FieldSubPathValue {
	return &CryptoKey_FieldSubPathValue{CryptoKey_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s CryptoKeyPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues meta.Meta_FieldPathArrayOfValues) *CryptoKey_FieldSubPathArrayOfValues {
	return &CryptoKey_FieldSubPathArrayOfValues{CryptoKey_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s CryptoKeyPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue meta.Meta_FieldPathArrayItemValue) *CryptoKey_FieldSubPathArrayItemValue {
	return &CryptoKey_FieldSubPathArrayItemValue{CryptoKey_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (CryptoKeyPathSelectorMetadata) CreateTime() CryptoKeyPathSelectorMetadataCreateTime {
	return CryptoKeyPathSelectorMetadataCreateTime{}
}

func (CryptoKeyPathSelectorMetadata) UpdateTime() CryptoKeyPathSelectorMetadataUpdateTime {
	return CryptoKeyPathSelectorMetadataUpdateTime{}
}

func (CryptoKeyPathSelectorMetadata) DeleteTime() CryptoKeyPathSelectorMetadataDeleteTime {
	return CryptoKeyPathSelectorMetadataDeleteTime{}
}

func (CryptoKeyPathSelectorMetadata) Uuid() CryptoKeyPathSelectorMetadataUuid {
	return CryptoKeyPathSelectorMetadataUuid{}
}

func (CryptoKeyPathSelectorMetadata) Tags() CryptoKeyPathSelectorMetadataTags {
	return CryptoKeyPathSelectorMetadataTags{}
}

func (CryptoKeyPathSelectorMetadata) Labels() CryptoKeyPathSelectorMetadataLabels {
	return CryptoKeyPathSelectorMetadataLabels{}
}

func (CryptoKeyPathSelectorMetadata) Annotations() CryptoKeyPathSelectorMetadataAnnotations {
	return CryptoKeyPathSelectorMetadataAnnotations{}
}

func (CryptoKeyPathSelectorMetadata) Generation() CryptoKeyPathSelectorMetadataGeneration {
	return CryptoKeyPathSelectorMetadataGeneration{}
}

func (CryptoKeyPathSelectorMetadata) ResourceVersion() CryptoKeyPathSelectorMetadataResourceVersion {
	return CryptoKeyPathSelectorMetadataResourceVersion{}
}

func (CryptoKeyPathSelectorMetadata) OwnerReferences() CryptoKeyPathSelectorMetadataOwnerReferences {
	return CryptoKeyPathSelectorMetadataOwnerReferences{}
}

func (CryptoKeyPathSelectorMetadata) Shards() CryptoKeyPathSelectorMetadataShards {
	return CryptoKeyPathSelectorMetadataShards{}
}

func (CryptoKeyPathSelectorMetadata) Syncing() CryptoKeyPathSelectorMetadataSyncing {
	return CryptoKeyPathSelectorMetadataSyncing{}
}

func (CryptoKeyPathSelectorMetadata) Lifecycle() CryptoKeyPathSelectorMetadataLifecycle {
	return CryptoKeyPathSelectorMetadataLifecycle{}
}

func (CryptoKeyPathSelectorMetadata) Services() CryptoKeyPathSelectorMetadataServices {
	return CryptoKeyPathSelectorMetadataServices{}
}

type CryptoKeyPathSelectorMetadataCreateTime struct{}

func (CryptoKeyPathSelectorMetadataCreateTime) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataCreateTime) WithValue(value *timestamppb.Timestamp) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataUpdateTime struct{}

func (CryptoKeyPathSelectorMetadataUpdateTime) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataUpdateTime) WithValue(value *timestamppb.Timestamp) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataDeleteTime struct{}

func (CryptoKeyPathSelectorMetadataDeleteTime) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataDeleteTime) WithValue(value *timestamppb.Timestamp) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataUuid struct{}

func (CryptoKeyPathSelectorMetadataUuid) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataUuid) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataTags struct{}

func (CryptoKeyPathSelectorMetadataTags) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

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

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

func (s CryptoKeyPathSelectorMetadataTags) WithItemValue(value string) *CryptoKey_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*CryptoKey_FieldSubPathArrayItemValue)
}

type CryptoKeyPathSelectorMetadataLabels struct{}

func (CryptoKeyPathSelectorMetadataLabels) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

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

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

func (CryptoKeyPathSelectorMetadataLabels) WithKey(key string) CryptoKeyMapPathSelectorMetadataLabels {
	return CryptoKeyMapPathSelectorMetadataLabels{key: key}
}

type CryptoKeyMapPathSelectorMetadataLabels struct {
	key string
}

func (s CryptoKeyMapPathSelectorMetadataLabels) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s CryptoKeyMapPathSelectorMetadataLabels) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataAnnotations struct{}

func (CryptoKeyPathSelectorMetadataAnnotations) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

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

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

func (CryptoKeyPathSelectorMetadataAnnotations) WithKey(key string) CryptoKeyMapPathSelectorMetadataAnnotations {
	return CryptoKeyMapPathSelectorMetadataAnnotations{key: key}
}

type CryptoKeyMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s CryptoKeyMapPathSelectorMetadataAnnotations) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s CryptoKeyMapPathSelectorMetadataAnnotations) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataGeneration struct{}

func (CryptoKeyPathSelectorMetadataGeneration) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataGeneration) WithValue(value int64) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataResourceVersion struct{}

func (CryptoKeyPathSelectorMetadataResourceVersion) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataResourceVersion) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferences struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferences) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

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

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

func (s CryptoKeyPathSelectorMetadataOwnerReferences) WithItemValue(value *meta.OwnerReference) *CryptoKey_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*CryptoKey_FieldSubPathArrayItemValue)
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) Kind() CryptoKeyPathSelectorMetadataOwnerReferencesKind {
	return CryptoKeyPathSelectorMetadataOwnerReferencesKind{}
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) Version() CryptoKeyPathSelectorMetadataOwnerReferencesVersion {
	return CryptoKeyPathSelectorMetadataOwnerReferencesVersion{}
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) Name() CryptoKeyPathSelectorMetadataOwnerReferencesName {
	return CryptoKeyPathSelectorMetadataOwnerReferencesName{}
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) Region() CryptoKeyPathSelectorMetadataOwnerReferencesRegion {
	return CryptoKeyPathSelectorMetadataOwnerReferencesRegion{}
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) Controller() CryptoKeyPathSelectorMetadataOwnerReferencesController {
	return CryptoKeyPathSelectorMetadataOwnerReferencesController{}
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) RequiresOwnerReference() CryptoKeyPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return CryptoKeyPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

func (CryptoKeyPathSelectorMetadataOwnerReferences) UnsetOnDelete() CryptoKeyPathSelectorMetadataOwnerReferencesUnsetOnDelete {
	return CryptoKeyPathSelectorMetadataOwnerReferencesUnsetOnDelete{}
}

type CryptoKeyPathSelectorMetadataOwnerReferencesKind struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesKind) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferencesVersion struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesVersion) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferencesName struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesName) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesName) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferencesRegion struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesRegion) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferencesController struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesController) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataOwnerReferencesUnsetOnDelete struct{}

func (CryptoKeyPathSelectorMetadataOwnerReferencesUnsetOnDelete) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().UnsetOnDelete().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithValue(value bool) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataShards struct{}

func (CryptoKeyPathSelectorMetadataShards) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

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

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

func (CryptoKeyPathSelectorMetadataShards) WithKey(key string) CryptoKeyMapPathSelectorMetadataShards {
	return CryptoKeyMapPathSelectorMetadataShards{key: key}
}

type CryptoKeyMapPathSelectorMetadataShards struct {
	key string
}

func (s CryptoKeyMapPathSelectorMetadataShards) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s CryptoKeyMapPathSelectorMetadataShards) WithValue(value int64) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataSyncing struct{}

func (CryptoKeyPathSelectorMetadataSyncing) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataSyncing) WithValue(value *meta.SyncingMeta) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

func (CryptoKeyPathSelectorMetadataSyncing) OwningRegion() CryptoKeyPathSelectorMetadataSyncingOwningRegion {
	return CryptoKeyPathSelectorMetadataSyncingOwningRegion{}
}

func (CryptoKeyPathSelectorMetadataSyncing) Regions() CryptoKeyPathSelectorMetadataSyncingRegions {
	return CryptoKeyPathSelectorMetadataSyncingRegions{}
}

type CryptoKeyPathSelectorMetadataSyncingOwningRegion struct{}

func (CryptoKeyPathSelectorMetadataSyncingOwningRegion) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataSyncingRegions struct{}

func (CryptoKeyPathSelectorMetadataSyncingRegions) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

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

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

func (s CryptoKeyPathSelectorMetadataSyncingRegions) WithItemValue(value string) *CryptoKey_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*CryptoKey_FieldSubPathArrayItemValue)
}

type CryptoKeyPathSelectorMetadataLifecycle struct{}

func (CryptoKeyPathSelectorMetadataLifecycle) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataLifecycle) WithValue(value *meta.Lifecycle) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

func (CryptoKeyPathSelectorMetadataLifecycle) State() CryptoKeyPathSelectorMetadataLifecycleState {
	return CryptoKeyPathSelectorMetadataLifecycleState{}
}

func (CryptoKeyPathSelectorMetadataLifecycle) BlockDeletion() CryptoKeyPathSelectorMetadataLifecycleBlockDeletion {
	return CryptoKeyPathSelectorMetadataLifecycleBlockDeletion{}
}

type CryptoKeyPathSelectorMetadataLifecycleState struct{}

func (CryptoKeyPathSelectorMetadataLifecycleState) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataLifecycleState) WithValue(value meta.Lifecycle_State) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataLifecycleBlockDeletion struct{}

func (CryptoKeyPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataServices struct{}

func (CryptoKeyPathSelectorMetadataServices) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

func (CryptoKeyPathSelectorMetadataServices) OwningService() CryptoKeyPathSelectorMetadataServicesOwningService {
	return CryptoKeyPathSelectorMetadataServicesOwningService{}
}

func (CryptoKeyPathSelectorMetadataServices) AllowedServices() CryptoKeyPathSelectorMetadataServicesAllowedServices {
	return CryptoKeyPathSelectorMetadataServicesAllowedServices{}
}

type CryptoKeyPathSelectorMetadataServicesOwningService struct{}

func (CryptoKeyPathSelectorMetadataServicesOwningService) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().OwningService().FieldPath(),
	}
}

func (s CryptoKeyPathSelectorMetadataServicesOwningService) WithValue(value string) *CryptoKey_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldSubPathValue)
}

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

type CryptoKeyPathSelectorMetadataServicesAllowedServices struct{}

func (CryptoKeyPathSelectorMetadataServicesAllowedServices) FieldPath() *CryptoKey_FieldSubPath {
	return &CryptoKey_FieldSubPath{
		selector: CryptoKey_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().AllowedServices().FieldPath(),
	}
}

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

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

func (s CryptoKeyPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *CryptoKey_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*CryptoKey_FieldSubPathArrayItemValue)
}

type CryptoKeyPathSelectorKey struct{}

func (CryptoKeyPathSelectorKey) FieldPath() *CryptoKey_FieldTerminalPath {
	return &CryptoKey_FieldTerminalPath{selector: CryptoKey_FieldPathSelectorKey}
}

func (s CryptoKeyPathSelectorKey) WithValue(value string) *CryptoKey_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*CryptoKey_FieldTerminalPathValue)
}

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