VolumeFluent (Fabric8 :: Kubernetes Model

java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.kubernetes.api.model.VolumeFluent<A>

Direct Known Subclasses:

NamedExtensionFluent.VolumeExtensionNested, PodSpecFluent.VolumesNested, VolumeBuilder, WatchEventFluent.VolumeObjectNested
```
public class VolumeFluent<A extends VolumeFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`VolumeFluent.AwsElasticBlockStoreNested<N>`
`class`	`VolumeFluent.AzureDiskNested<N>`
`class`	`VolumeFluent.AzureFileNested<N>`
`class`	`VolumeFluent.CephfsNested<N>`
`class`	`VolumeFluent.CinderNested<N>`
`class`	`VolumeFluent.ConfigMapNested<N>`
`class`	`VolumeFluent.CsiNested<N>`
`class`	`VolumeFluent.DownwardAPINested<N>`
`class`	`VolumeFluent.EmptyDirNested<N>`
`class`	`VolumeFluent.EphemeralNested<N>`
`class`	`VolumeFluent.FcNested<N>`
`class`	`VolumeFluent.FlexVolumeNested<N>`
`class`	`VolumeFluent.FlockerNested<N>`
`class`	`VolumeFluent.GcePersistentDiskNested<N>`
`class`	`VolumeFluent.GitRepoNested<N>`
`class`	`VolumeFluent.GlusterfsNested<N>`
`class`	`VolumeFluent.HostPathNested<N>`
`class`	`VolumeFluent.IscsiNested<N>`
`class`	`VolumeFluent.NfsNested<N>`
`class`	`VolumeFluent.PersistentVolumeClaimNested<N>`
`class`	`VolumeFluent.PhotonPersistentDiskNested<N>`
`class`	`VolumeFluent.PortworxVolumeNested<N>`
`class`	`VolumeFluent.ProjectedNested<N>`
`class`	`VolumeFluent.QuobyteNested<N>`
`class`	`VolumeFluent.RbdNested<N>`
`class`	`VolumeFluent.ScaleIONested<N>`
`class`	`VolumeFluent.SecretNested<N>`
`class`	`VolumeFluent.StorageosNested<N>`
`class`	`VolumeFluent.VsphereVolumeNested<N>`

Field Summary
- Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
  _visitables, VISIT

Constructor Summary

Constructors
Constructor and Description

VolumeFluent()

VolumeFluent(Volume instance)

Constructors
Constructor and Description
`VolumeFluent()`
`VolumeFluent(Volume instance)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToAdditionalProperties(String key, Object value)`
`AWSElasticBlockStoreVolumeSource`	`buildAwsElasticBlockStore()`
`AzureDiskVolumeSource`	`buildAzureDisk()`
`AzureFileVolumeSource`	`buildAzureFile()`
`CephFSVolumeSource`	`buildCephfs()`
`CinderVolumeSource`	`buildCinder()`
`ConfigMapVolumeSource`	`buildConfigMap()`
`CSIVolumeSource`	`buildCsi()`
`DownwardAPIVolumeSource`	`buildDownwardAPI()`
`EmptyDirVolumeSource`	`buildEmptyDir()`
`EphemeralVolumeSource`	`buildEphemeral()`
`FCVolumeSource`	`buildFc()`
`FlexVolumeSource`	`buildFlexVolume()`
`FlockerVolumeSource`	`buildFlocker()`
`GCEPersistentDiskVolumeSource`	`buildGcePersistentDisk()`
`GitRepoVolumeSource`	`buildGitRepo()`
`GlusterfsVolumeSource`	`buildGlusterfs()`
`HostPathVolumeSource`	`buildHostPath()`
`ISCSIVolumeSource`	`buildIscsi()`
`NFSVolumeSource`	`buildNfs()`
`PersistentVolumeClaimVolumeSource`	`buildPersistentVolumeClaim()`
`PhotonPersistentDiskVolumeSource`	`buildPhotonPersistentDisk()`
`PortworxVolumeSource`	`buildPortworxVolume()`
`ProjectedVolumeSource`	`buildProjected()`
`QuobyteVolumeSource`	`buildQuobyte()`
`RBDVolumeSource`	`buildRbd()`
`ScaleIOVolumeSource`	`buildScaleIO()`
`SecretVolumeSource`	`buildSecret()`
`StorageOSVolumeSource`	`buildStorageos()`
`VsphereVirtualDiskVolumeSource`	`buildVsphereVolume()`
`protected void`	`copyInstance(Volume instance)`
`VolumeFluent.AwsElasticBlockStoreNested<A>`	`editAwsElasticBlockStore()`
`VolumeFluent.AzureDiskNested<A>`	`editAzureDisk()`
`VolumeFluent.AzureFileNested<A>`	`editAzureFile()`
`VolumeFluent.CephfsNested<A>`	`editCephfs()`
`VolumeFluent.CinderNested<A>`	`editCinder()`
`VolumeFluent.ConfigMapNested<A>`	`editConfigMap()`
`VolumeFluent.CsiNested<A>`	`editCsi()`
`VolumeFluent.DownwardAPINested<A>`	`editDownwardAPI()`
`VolumeFluent.EmptyDirNested<A>`	`editEmptyDir()`
`VolumeFluent.EphemeralNested<A>`	`editEphemeral()`
`VolumeFluent.FcNested<A>`	`editFc()`
`VolumeFluent.FlexVolumeNested<A>`	`editFlexVolume()`
`VolumeFluent.FlockerNested<A>`	`editFlocker()`
`VolumeFluent.GcePersistentDiskNested<A>`	`editGcePersistentDisk()`
`VolumeFluent.GitRepoNested<A>`	`editGitRepo()`
`VolumeFluent.GlusterfsNested<A>`	`editGlusterfs()`
`VolumeFluent.HostPathNested<A>`	`editHostPath()`
`VolumeFluent.IscsiNested<A>`	`editIscsi()`
`VolumeFluent.NfsNested<A>`	`editNfs()`
`VolumeFluent.AwsElasticBlockStoreNested<A>`	`editOrNewAwsElasticBlockStore()`
`VolumeFluent.AwsElasticBlockStoreNested<A>`	`editOrNewAwsElasticBlockStoreLike(AWSElasticBlockStoreVolumeSource item)`
`VolumeFluent.AzureDiskNested<A>`	`editOrNewAzureDisk()`
`VolumeFluent.AzureDiskNested<A>`	`editOrNewAzureDiskLike(AzureDiskVolumeSource item)`
`VolumeFluent.AzureFileNested<A>`	`editOrNewAzureFile()`
`VolumeFluent.AzureFileNested<A>`	`editOrNewAzureFileLike(AzureFileVolumeSource item)`
`VolumeFluent.CephfsNested<A>`	`editOrNewCephfs()`
`VolumeFluent.CephfsNested<A>`	`editOrNewCephfsLike(CephFSVolumeSource item)`
`VolumeFluent.CinderNested<A>`	`editOrNewCinder()`
`VolumeFluent.CinderNested<A>`	`editOrNewCinderLike(CinderVolumeSource item)`
`VolumeFluent.ConfigMapNested<A>`	`editOrNewConfigMap()`
`VolumeFluent.ConfigMapNested<A>`	`editOrNewConfigMapLike(ConfigMapVolumeSource item)`
`VolumeFluent.CsiNested<A>`	`editOrNewCsi()`
`VolumeFluent.CsiNested<A>`	`editOrNewCsiLike(CSIVolumeSource item)`
`VolumeFluent.DownwardAPINested<A>`	`editOrNewDownwardAPI()`
`VolumeFluent.DownwardAPINested<A>`	`editOrNewDownwardAPILike(DownwardAPIVolumeSource item)`
`VolumeFluent.EmptyDirNested<A>`	`editOrNewEmptyDir()`
`VolumeFluent.EmptyDirNested<A>`	`editOrNewEmptyDirLike(EmptyDirVolumeSource item)`
`VolumeFluent.EphemeralNested<A>`	`editOrNewEphemeral()`
`VolumeFluent.EphemeralNested<A>`	`editOrNewEphemeralLike(EphemeralVolumeSource item)`
`VolumeFluent.FcNested<A>`	`editOrNewFc()`
`VolumeFluent.FcNested<A>`	`editOrNewFcLike(FCVolumeSource item)`
`VolumeFluent.FlexVolumeNested<A>`	`editOrNewFlexVolume()`
`VolumeFluent.FlexVolumeNested<A>`	`editOrNewFlexVolumeLike(FlexVolumeSource item)`
`VolumeFluent.FlockerNested<A>`	`editOrNewFlocker()`
`VolumeFluent.FlockerNested<A>`	`editOrNewFlockerLike(FlockerVolumeSource item)`
`VolumeFluent.GcePersistentDiskNested<A>`	`editOrNewGcePersistentDisk()`
`VolumeFluent.GcePersistentDiskNested<A>`	`editOrNewGcePersistentDiskLike(GCEPersistentDiskVolumeSource item)`
`VolumeFluent.GitRepoNested<A>`	`editOrNewGitRepo()`
`VolumeFluent.GitRepoNested<A>`	`editOrNewGitRepoLike(GitRepoVolumeSource item)`
`VolumeFluent.GlusterfsNested<A>`	`editOrNewGlusterfs()`
`VolumeFluent.GlusterfsNested<A>`	`editOrNewGlusterfsLike(GlusterfsVolumeSource item)`
`VolumeFluent.HostPathNested<A>`	`editOrNewHostPath()`
`VolumeFluent.HostPathNested<A>`	`editOrNewHostPathLike(HostPathVolumeSource item)`
`VolumeFluent.IscsiNested<A>`	`editOrNewIscsi()`
`VolumeFluent.IscsiNested<A>`	`editOrNewIscsiLike(ISCSIVolumeSource item)`
`VolumeFluent.NfsNested<A>`	`editOrNewNfs()`
`VolumeFluent.NfsNested<A>`	`editOrNewNfsLike(NFSVolumeSource item)`
`VolumeFluent.PersistentVolumeClaimNested<A>`	`editOrNewPersistentVolumeClaim()`
`VolumeFluent.PersistentVolumeClaimNested<A>`	`editOrNewPersistentVolumeClaimLike(PersistentVolumeClaimVolumeSource item)`
`VolumeFluent.PhotonPersistentDiskNested<A>`	`editOrNewPhotonPersistentDisk()`
`VolumeFluent.PhotonPersistentDiskNested<A>`	`editOrNewPhotonPersistentDiskLike(PhotonPersistentDiskVolumeSource item)`
`VolumeFluent.PortworxVolumeNested<A>`	`editOrNewPortworxVolume()`
`VolumeFluent.PortworxVolumeNested<A>`	`editOrNewPortworxVolumeLike(PortworxVolumeSource item)`
`VolumeFluent.ProjectedNested<A>`	`editOrNewProjected()`
`VolumeFluent.ProjectedNested<A>`	`editOrNewProjectedLike(ProjectedVolumeSource item)`
`VolumeFluent.QuobyteNested<A>`	`editOrNewQuobyte()`
`VolumeFluent.QuobyteNested<A>`	`editOrNewQuobyteLike(QuobyteVolumeSource item)`
`VolumeFluent.RbdNested<A>`	`editOrNewRbd()`
`VolumeFluent.RbdNested<A>`	`editOrNewRbdLike(RBDVolumeSource item)`
`VolumeFluent.ScaleIONested<A>`	`editOrNewScaleIO()`
`VolumeFluent.ScaleIONested<A>`	`editOrNewScaleIOLike(ScaleIOVolumeSource item)`
`VolumeFluent.SecretNested<A>`	`editOrNewSecret()`
`VolumeFluent.SecretNested<A>`	`editOrNewSecretLike(SecretVolumeSource item)`
`VolumeFluent.StorageosNested<A>`	`editOrNewStorageos()`
`VolumeFluent.StorageosNested<A>`	`editOrNewStorageosLike(StorageOSVolumeSource item)`
`VolumeFluent.VsphereVolumeNested<A>`	`editOrNewVsphereVolume()`
`VolumeFluent.VsphereVolumeNested<A>`	`editOrNewVsphereVolumeLike(VsphereVirtualDiskVolumeSource item)`
`VolumeFluent.PersistentVolumeClaimNested<A>`	`editPersistentVolumeClaim()`
`VolumeFluent.PhotonPersistentDiskNested<A>`	`editPhotonPersistentDisk()`
`VolumeFluent.PortworxVolumeNested<A>`	`editPortworxVolume()`
`VolumeFluent.ProjectedNested<A>`	`editProjected()`
`VolumeFluent.QuobyteNested<A>`	`editQuobyte()`
`VolumeFluent.RbdNested<A>`	`editRbd()`
`VolumeFluent.ScaleIONested<A>`	`editScaleIO()`
`VolumeFluent.SecretNested<A>`	`editSecret()`
`VolumeFluent.StorageosNested<A>`	`editStorageos()`
`VolumeFluent.VsphereVolumeNested<A>`	`editVsphereVolume()`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getName()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasAwsElasticBlockStore()`
`boolean`	`hasAzureDisk()`
`boolean`	`hasAzureFile()`
`boolean`	`hasCephfs()`
`boolean`	`hasCinder()`
`boolean`	`hasConfigMap()`
`boolean`	`hasCsi()`
`boolean`	`hasDownwardAPI()`
`boolean`	`hasEmptyDir()`
`boolean`	`hasEphemeral()`
`boolean`	`hasFc()`
`boolean`	`hasFlexVolume()`
`boolean`	`hasFlocker()`
`boolean`	`hasGcePersistentDisk()`
`boolean`	`hasGitRepo()`
`boolean`	`hasGlusterfs()`
`int`	`hashCode()`
`boolean`	`hasHostPath()`
`boolean`	`hasIscsi()`
`boolean`	`hasName()`
`boolean`	`hasNfs()`
`boolean`	`hasPersistentVolumeClaim()`
`boolean`	`hasPhotonPersistentDisk()`
`boolean`	`hasPortworxVolume()`
`boolean`	`hasProjected()`
`boolean`	`hasQuobyte()`
`boolean`	`hasRbd()`
`boolean`	`hasScaleIO()`
`boolean`	`hasSecret()`
`boolean`	`hasStorageos()`
`boolean`	`hasVsphereVolume()`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromAdditionalProperties(String key)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withAwsElasticBlockStore(AWSElasticBlockStoreVolumeSource awsElasticBlockStore)`
`A`	`withAzureDisk(AzureDiskVolumeSource azureDisk)`
`A`	`withAzureFile(AzureFileVolumeSource azureFile)`
`A`	`withCephfs(CephFSVolumeSource cephfs)`
`A`	`withCinder(CinderVolumeSource cinder)`
`A`	`withConfigMap(ConfigMapVolumeSource configMap)`
`A`	`withCsi(CSIVolumeSource csi)`
`A`	`withDownwardAPI(DownwardAPIVolumeSource downwardAPI)`
`A`	`withEmptyDir(EmptyDirVolumeSource emptyDir)`
`A`	`withEphemeral(EphemeralVolumeSource ephemeral)`
`A`	`withFc(FCVolumeSource fc)`
`A`	`withFlexVolume(FlexVolumeSource flexVolume)`
`A`	`withFlocker(FlockerVolumeSource flocker)`
`A`	`withGcePersistentDisk(GCEPersistentDiskVolumeSource gcePersistentDisk)`
`A`	`withGitRepo(GitRepoVolumeSource gitRepo)`
`A`	`withGlusterfs(GlusterfsVolumeSource glusterfs)`
`A`	`withHostPath(HostPathVolumeSource hostPath)`
`A`	`withIscsi(ISCSIVolumeSource iscsi)`
`A`	`withName(String name)`
`VolumeFluent.AwsElasticBlockStoreNested<A>`	`withNewAwsElasticBlockStore()`
`A`	`withNewAwsElasticBlockStore(String fsType, Integer partition, Boolean readOnly, String volumeID)`
`VolumeFluent.AwsElasticBlockStoreNested<A>`	`withNewAwsElasticBlockStoreLike(AWSElasticBlockStoreVolumeSource item)`
`VolumeFluent.AzureDiskNested<A>`	`withNewAzureDisk()`
`VolumeFluent.AzureDiskNested<A>`	`withNewAzureDiskLike(AzureDiskVolumeSource item)`
`VolumeFluent.AzureFileNested<A>`	`withNewAzureFile()`
`A`	`withNewAzureFile(Boolean readOnly, String secretName, String shareName)`
`VolumeFluent.AzureFileNested<A>`	`withNewAzureFileLike(AzureFileVolumeSource item)`
`VolumeFluent.CephfsNested<A>`	`withNewCephfs()`
`VolumeFluent.CephfsNested<A>`	`withNewCephfsLike(CephFSVolumeSource item)`
`VolumeFluent.CinderNested<A>`	`withNewCinder()`
`VolumeFluent.CinderNested<A>`	`withNewCinderLike(CinderVolumeSource item)`
`VolumeFluent.ConfigMapNested<A>`	`withNewConfigMap()`
`VolumeFluent.ConfigMapNested<A>`	`withNewConfigMapLike(ConfigMapVolumeSource item)`
`VolumeFluent.CsiNested<A>`	`withNewCsi()`
`VolumeFluent.CsiNested<A>`	`withNewCsiLike(CSIVolumeSource item)`
`VolumeFluent.DownwardAPINested<A>`	`withNewDownwardAPI()`
`VolumeFluent.DownwardAPINested<A>`	`withNewDownwardAPILike(DownwardAPIVolumeSource item)`
`VolumeFluent.EmptyDirNested<A>`	`withNewEmptyDir()`
`VolumeFluent.EmptyDirNested<A>`	`withNewEmptyDirLike(EmptyDirVolumeSource item)`
`VolumeFluent.EphemeralNested<A>`	`withNewEphemeral()`
`VolumeFluent.EphemeralNested<A>`	`withNewEphemeralLike(EphemeralVolumeSource item)`
`VolumeFluent.FcNested<A>`	`withNewFc()`
`VolumeFluent.FcNested<A>`	`withNewFcLike(FCVolumeSource item)`
`VolumeFluent.FlexVolumeNested<A>`	`withNewFlexVolume()`
`VolumeFluent.FlexVolumeNested<A>`	`withNewFlexVolumeLike(FlexVolumeSource item)`
`VolumeFluent.FlockerNested<A>`	`withNewFlocker()`
`A`	`withNewFlocker(String datasetName, String datasetUUID)`
`VolumeFluent.FlockerNested<A>`	`withNewFlockerLike(FlockerVolumeSource item)`
`VolumeFluent.GcePersistentDiskNested<A>`	`withNewGcePersistentDisk()`
`A`	`withNewGcePersistentDisk(String fsType, Integer partition, String pdName, Boolean readOnly)`
`VolumeFluent.GcePersistentDiskNested<A>`	`withNewGcePersistentDiskLike(GCEPersistentDiskVolumeSource item)`
`VolumeFluent.GitRepoNested<A>`	`withNewGitRepo()`
`A`	`withNewGitRepo(String directory, String repository, String revision)`
`VolumeFluent.GitRepoNested<A>`	`withNewGitRepoLike(GitRepoVolumeSource item)`
`VolumeFluent.GlusterfsNested<A>`	`withNewGlusterfs()`
`A`	`withNewGlusterfs(String endpoints, String path, Boolean readOnly)`
`VolumeFluent.GlusterfsNested<A>`	`withNewGlusterfsLike(GlusterfsVolumeSource item)`
`VolumeFluent.HostPathNested<A>`	`withNewHostPath()`
`A`	`withNewHostPath(String path, String type)`
`VolumeFluent.HostPathNested<A>`	`withNewHostPathLike(HostPathVolumeSource item)`
`VolumeFluent.IscsiNested<A>`	`withNewIscsi()`
`VolumeFluent.IscsiNested<A>`	`withNewIscsiLike(ISCSIVolumeSource item)`
`VolumeFluent.NfsNested<A>`	`withNewNfs()`
`A`	`withNewNfs(String path, Boolean readOnly, String server)`
`VolumeFluent.NfsNested<A>`	`withNewNfsLike(NFSVolumeSource item)`
`VolumeFluent.PersistentVolumeClaimNested<A>`	`withNewPersistentVolumeClaim()`
`A`	`withNewPersistentVolumeClaim(String claimName, Boolean readOnly)`
`VolumeFluent.PersistentVolumeClaimNested<A>`	`withNewPersistentVolumeClaimLike(PersistentVolumeClaimVolumeSource item)`
`VolumeFluent.PhotonPersistentDiskNested<A>`	`withNewPhotonPersistentDisk()`
`A`	`withNewPhotonPersistentDisk(String fsType, String pdID)`
`VolumeFluent.PhotonPersistentDiskNested<A>`	`withNewPhotonPersistentDiskLike(PhotonPersistentDiskVolumeSource item)`
`VolumeFluent.PortworxVolumeNested<A>`	`withNewPortworxVolume()`
`A`	`withNewPortworxVolume(String fsType, Boolean readOnly, String volumeID)`
`VolumeFluent.PortworxVolumeNested<A>`	`withNewPortworxVolumeLike(PortworxVolumeSource item)`
`VolumeFluent.ProjectedNested<A>`	`withNewProjected()`
`VolumeFluent.ProjectedNested<A>`	`withNewProjectedLike(ProjectedVolumeSource item)`
`VolumeFluent.QuobyteNested<A>`	`withNewQuobyte()`
`VolumeFluent.QuobyteNested<A>`	`withNewQuobyteLike(QuobyteVolumeSource item)`
`VolumeFluent.RbdNested<A>`	`withNewRbd()`
`VolumeFluent.RbdNested<A>`	`withNewRbdLike(RBDVolumeSource item)`
`VolumeFluent.ScaleIONested<A>`	`withNewScaleIO()`
`VolumeFluent.ScaleIONested<A>`	`withNewScaleIOLike(ScaleIOVolumeSource item)`
`VolumeFluent.SecretNested<A>`	`withNewSecret()`
`VolumeFluent.SecretNested<A>`	`withNewSecretLike(SecretVolumeSource item)`
`VolumeFluent.StorageosNested<A>`	`withNewStorageos()`
`VolumeFluent.StorageosNested<A>`	`withNewStorageosLike(StorageOSVolumeSource item)`
`VolumeFluent.VsphereVolumeNested<A>`	`withNewVsphereVolume()`
`A`	`withNewVsphereVolume(String fsType, String storagePolicyID, String storagePolicyName, String volumePath)`
`VolumeFluent.VsphereVolumeNested<A>`	`withNewVsphereVolumeLike(VsphereVirtualDiskVolumeSource item)`
`A`	`withNfs(NFSVolumeSource nfs)`
`A`	`withPersistentVolumeClaim(PersistentVolumeClaimVolumeSource persistentVolumeClaim)`
`A`	`withPhotonPersistentDisk(PhotonPersistentDiskVolumeSource photonPersistentDisk)`
`A`	`withPortworxVolume(PortworxVolumeSource portworxVolume)`
`A`	`withProjected(ProjectedVolumeSource projected)`
`A`	`withQuobyte(QuobyteVolumeSource quobyte)`
`A`	`withRbd(RBDVolumeSource rbd)`
`A`	`withScaleIO(ScaleIOVolumeSource scaleIO)`
`A`	`withSecret(SecretVolumeSource secret)`
`A`	`withStorageos(StorageOSVolumeSource storageos)`
`A`	`withVsphereVolume(VsphereVirtualDiskVolumeSource vsphereVolume)`

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

VolumeFluent
```
public VolumeFluent()
```

VolumeFluent
```
public VolumeFluent(Volume instance)
```

Method Detail

copyInstance

protected void copyInstance(Volume instance)

buildAwsElasticBlockStore

public AWSElasticBlockStoreVolumeSource buildAwsElasticBlockStore()

withAwsElasticBlockStore

public A withAwsElasticBlockStore(AWSElasticBlockStoreVolumeSource awsElasticBlockStore)

hasAwsElasticBlockStore

public boolean hasAwsElasticBlockStore()

withNewAwsElasticBlockStore

public A withNewAwsElasticBlockStore(String fsType,
                                     Integer partition,
                                     Boolean readOnly,
                                     String volumeID)

withNewAwsElasticBlockStore

public VolumeFluent.AwsElasticBlockStoreNested<A> withNewAwsElasticBlockStore()

withNewAwsElasticBlockStoreLike

public VolumeFluent.AwsElasticBlockStoreNested<A> withNewAwsElasticBlockStoreLike(AWSElasticBlockStoreVolumeSource item)

editAwsElasticBlockStore

public VolumeFluent.AwsElasticBlockStoreNested<A> editAwsElasticBlockStore()

editOrNewAwsElasticBlockStore

public VolumeFluent.AwsElasticBlockStoreNested<A> editOrNewAwsElasticBlockStore()

editOrNewAwsElasticBlockStoreLike

public VolumeFluent.AwsElasticBlockStoreNested<A> editOrNewAwsElasticBlockStoreLike(AWSElasticBlockStoreVolumeSource item)

buildAzureDisk

public AzureDiskVolumeSource buildAzureDisk()

withAzureDisk

public A withAzureDisk(AzureDiskVolumeSource azureDisk)

hasAzureDisk
```
public boolean hasAzureDisk()
```

withNewAzureDisk

public VolumeFluent.AzureDiskNested<A> withNewAzureDisk()

withNewAzureDiskLike

public VolumeFluent.AzureDiskNested<A> withNewAzureDiskLike(AzureDiskVolumeSource item)

editAzureDisk

public VolumeFluent.AzureDiskNested<A> editAzureDisk()

editOrNewAzureDisk

public VolumeFluent.AzureDiskNested<A> editOrNewAzureDisk()

editOrNewAzureDiskLike

public VolumeFluent.AzureDiskNested<A> editOrNewAzureDiskLike(AzureDiskVolumeSource item)

buildAzureFile

public AzureFileVolumeSource buildAzureFile()

withAzureFile

public A withAzureFile(AzureFileVolumeSource azureFile)

hasAzureFile
```
public boolean hasAzureFile()
```

withNewAzureFile

public A withNewAzureFile(Boolean readOnly,
                          String secretName,
                          String shareName)

withNewAzureFile

public VolumeFluent.AzureFileNested<A> withNewAzureFile()

withNewAzureFileLike

public VolumeFluent.AzureFileNested<A> withNewAzureFileLike(AzureFileVolumeSource item)

editAzureFile

public VolumeFluent.AzureFileNested<A> editAzureFile()

editOrNewAzureFile

public VolumeFluent.AzureFileNested<A> editOrNewAzureFile()

editOrNewAzureFileLike

public VolumeFluent.AzureFileNested<A> editOrNewAzureFileLike(AzureFileVolumeSource item)

buildCephfs

public CephFSVolumeSource buildCephfs()

withCephfs

public A withCephfs(CephFSVolumeSource cephfs)

hasCephfs
```
public boolean hasCephfs()
```

withNewCephfs

public VolumeFluent.CephfsNested<A> withNewCephfs()

withNewCephfsLike

public VolumeFluent.CephfsNested<A> withNewCephfsLike(CephFSVolumeSource item)

editCephfs

public VolumeFluent.CephfsNested<A> editCephfs()

editOrNewCephfs

public VolumeFluent.CephfsNested<A> editOrNewCephfs()

editOrNewCephfsLike

public VolumeFluent.CephfsNested<A> editOrNewCephfsLike(CephFSVolumeSource item)

buildCinder

public CinderVolumeSource buildCinder()

withCinder

public A withCinder(CinderVolumeSource cinder)

hasCinder
```
public boolean hasCinder()
```

withNewCinder

public VolumeFluent.CinderNested<A> withNewCinder()

withNewCinderLike

public VolumeFluent.CinderNested<A> withNewCinderLike(CinderVolumeSource item)

editCinder

public VolumeFluent.CinderNested<A> editCinder()

editOrNewCinder

public VolumeFluent.CinderNested<A> editOrNewCinder()

editOrNewCinderLike

public VolumeFluent.CinderNested<A> editOrNewCinderLike(CinderVolumeSource item)

buildConfigMap

public ConfigMapVolumeSource buildConfigMap()

withConfigMap

public A withConfigMap(ConfigMapVolumeSource configMap)

hasConfigMap
```
public boolean hasConfigMap()
```

withNewConfigMap

public VolumeFluent.ConfigMapNested<A> withNewConfigMap()

withNewConfigMapLike

public VolumeFluent.ConfigMapNested<A> withNewConfigMapLike(ConfigMapVolumeSource item)

editConfigMap

public VolumeFluent.ConfigMapNested<A> editConfigMap()

editOrNewConfigMap

public VolumeFluent.ConfigMapNested<A> editOrNewConfigMap()

editOrNewConfigMapLike

public VolumeFluent.ConfigMapNested<A> editOrNewConfigMapLike(ConfigMapVolumeSource item)

buildCsi
```
public CSIVolumeSource buildCsi()
```

withCsi

public A withCsi(CSIVolumeSource csi)

hasCsi
```
public boolean hasCsi()
```

withNewCsi

public VolumeFluent.CsiNested<A> withNewCsi()

withNewCsiLike

public VolumeFluent.CsiNested<A> withNewCsiLike(CSIVolumeSource item)

editCsi

public VolumeFluent.CsiNested<A> editCsi()

editOrNewCsi

public VolumeFluent.CsiNested<A> editOrNewCsi()

editOrNewCsiLike

public VolumeFluent.CsiNested<A> editOrNewCsiLike(CSIVolumeSource item)

buildDownwardAPI

public DownwardAPIVolumeSource buildDownwardAPI()

withDownwardAPI

public A withDownwardAPI(DownwardAPIVolumeSource downwardAPI)

hasDownwardAPI
```
public boolean hasDownwardAPI()
```

withNewDownwardAPI

public VolumeFluent.DownwardAPINested<A> withNewDownwardAPI()

withNewDownwardAPILike

public VolumeFluent.DownwardAPINested<A> withNewDownwardAPILike(DownwardAPIVolumeSource item)

editDownwardAPI

public VolumeFluent.DownwardAPINested<A> editDownwardAPI()

editOrNewDownwardAPI

public VolumeFluent.DownwardAPINested<A> editOrNewDownwardAPI()

editOrNewDownwardAPILike

public VolumeFluent.DownwardAPINested<A> editOrNewDownwardAPILike(DownwardAPIVolumeSource item)

buildEmptyDir

public EmptyDirVolumeSource buildEmptyDir()

withEmptyDir

public A withEmptyDir(EmptyDirVolumeSource emptyDir)

hasEmptyDir
```
public boolean hasEmptyDir()
```

withNewEmptyDir

public VolumeFluent.EmptyDirNested<A> withNewEmptyDir()

withNewEmptyDirLike

public VolumeFluent.EmptyDirNested<A> withNewEmptyDirLike(EmptyDirVolumeSource item)

editEmptyDir

public VolumeFluent.EmptyDirNested<A> editEmptyDir()

editOrNewEmptyDir

public VolumeFluent.EmptyDirNested<A> editOrNewEmptyDir()

editOrNewEmptyDirLike

public VolumeFluent.EmptyDirNested<A> editOrNewEmptyDirLike(EmptyDirVolumeSource item)

buildEphemeral

public EphemeralVolumeSource buildEphemeral()

withEphemeral

public A withEphemeral(EphemeralVolumeSource ephemeral)

hasEphemeral
```
public boolean hasEphemeral()
```

withNewEphemeral

public VolumeFluent.EphemeralNested<A> withNewEphemeral()

withNewEphemeralLike

public VolumeFluent.EphemeralNested<A> withNewEphemeralLike(EphemeralVolumeSource item)

editEphemeral

public VolumeFluent.EphemeralNested<A> editEphemeral()

editOrNewEphemeral

public VolumeFluent.EphemeralNested<A> editOrNewEphemeral()

editOrNewEphemeralLike

public VolumeFluent.EphemeralNested<A> editOrNewEphemeralLike(EphemeralVolumeSource item)

buildFc
```
public FCVolumeSource buildFc()
```

withFc
```
public A withFc(FCVolumeSource fc)
```

hasFc
```
public boolean hasFc()
```

withNewFc

public VolumeFluent.FcNested<A> withNewFc()

withNewFcLike

public VolumeFluent.FcNested<A> withNewFcLike(FCVolumeSource item)

editFc

public VolumeFluent.FcNested<A> editFc()

editOrNewFc

public VolumeFluent.FcNested<A> editOrNewFc()

editOrNewFcLike

public VolumeFluent.FcNested<A> editOrNewFcLike(FCVolumeSource item)

buildFlexVolume

public FlexVolumeSource buildFlexVolume()

withFlexVolume

public A withFlexVolume(FlexVolumeSource flexVolume)

hasFlexVolume
```
public boolean hasFlexVolume()
```

withNewFlexVolume

public VolumeFluent.FlexVolumeNested<A> withNewFlexVolume()

withNewFlexVolumeLike

public VolumeFluent.FlexVolumeNested<A> withNewFlexVolumeLike(FlexVolumeSource item)

editFlexVolume

public VolumeFluent.FlexVolumeNested<A> editFlexVolume()

editOrNewFlexVolume

public VolumeFluent.FlexVolumeNested<A> editOrNewFlexVolume()

editOrNewFlexVolumeLike

public VolumeFluent.FlexVolumeNested<A> editOrNewFlexVolumeLike(FlexVolumeSource item)

buildFlocker

public FlockerVolumeSource buildFlocker()

withFlocker

public A withFlocker(FlockerVolumeSource flocker)

hasFlocker
```
public boolean hasFlocker()
```

withNewFlocker

public A withNewFlocker(String datasetName,
                        String datasetUUID)

withNewFlocker

public VolumeFluent.FlockerNested<A> withNewFlocker()

withNewFlockerLike

public VolumeFluent.FlockerNested<A> withNewFlockerLike(FlockerVolumeSource item)

editFlocker

public VolumeFluent.FlockerNested<A> editFlocker()

editOrNewFlocker

public VolumeFluent.FlockerNested<A> editOrNewFlocker()

editOrNewFlockerLike

public VolumeFluent.FlockerNested<A> editOrNewFlockerLike(FlockerVolumeSource item)

buildGcePersistentDisk

public GCEPersistentDiskVolumeSource buildGcePersistentDisk()

withGcePersistentDisk

public A withGcePersistentDisk(GCEPersistentDiskVolumeSource gcePersistentDisk)

hasGcePersistentDisk
```
public boolean hasGcePersistentDisk()
```

withNewGcePersistentDisk

public A withNewGcePersistentDisk(String fsType,
                                  Integer partition,
                                  String pdName,
                                  Boolean readOnly)

withNewGcePersistentDisk

public VolumeFluent.GcePersistentDiskNested<A> withNewGcePersistentDisk()

withNewGcePersistentDiskLike

public VolumeFluent.GcePersistentDiskNested<A> withNewGcePersistentDiskLike(GCEPersistentDiskVolumeSource item)

editGcePersistentDisk

public VolumeFluent.GcePersistentDiskNested<A> editGcePersistentDisk()

editOrNewGcePersistentDisk

public VolumeFluent.GcePersistentDiskNested<A> editOrNewGcePersistentDisk()

editOrNewGcePersistentDiskLike

public VolumeFluent.GcePersistentDiskNested<A> editOrNewGcePersistentDiskLike(GCEPersistentDiskVolumeSource item)

buildGitRepo

public GitRepoVolumeSource buildGitRepo()

withGitRepo

public A withGitRepo(GitRepoVolumeSource gitRepo)

hasGitRepo
```
public boolean hasGitRepo()
```

withNewGitRepo

public A withNewGitRepo(String directory,
                        String repository,
                        String revision)

withNewGitRepo

public VolumeFluent.GitRepoNested<A> withNewGitRepo()

withNewGitRepoLike

public VolumeFluent.GitRepoNested<A> withNewGitRepoLike(GitRepoVolumeSource item)

editGitRepo

public VolumeFluent.GitRepoNested<A> editGitRepo()

editOrNewGitRepo

public VolumeFluent.GitRepoNested<A> editOrNewGitRepo()

editOrNewGitRepoLike

public VolumeFluent.GitRepoNested<A> editOrNewGitRepoLike(GitRepoVolumeSource item)

buildGlusterfs

public GlusterfsVolumeSource buildGlusterfs()

withGlusterfs

public A withGlusterfs(GlusterfsVolumeSource glusterfs)

hasGlusterfs
```
public boolean hasGlusterfs()
```

withNewGlusterfs

public A withNewGlusterfs(String endpoints,
                          String path,
                          Boolean readOnly)

withNewGlusterfs

public VolumeFluent.GlusterfsNested<A> withNewGlusterfs()

withNewGlusterfsLike

public VolumeFluent.GlusterfsNested<A> withNewGlusterfsLike(GlusterfsVolumeSource item)

editGlusterfs

public VolumeFluent.GlusterfsNested<A> editGlusterfs()

editOrNewGlusterfs

public VolumeFluent.GlusterfsNested<A> editOrNewGlusterfs()

editOrNewGlusterfsLike

public VolumeFluent.GlusterfsNested<A> editOrNewGlusterfsLike(GlusterfsVolumeSource item)

buildHostPath

public HostPathVolumeSource buildHostPath()

withHostPath

public A withHostPath(HostPathVolumeSource hostPath)

hasHostPath
```
public boolean hasHostPath()
```

withNewHostPath

public A withNewHostPath(String path,
                         String type)

withNewHostPath

public VolumeFluent.HostPathNested<A> withNewHostPath()

withNewHostPathLike

public VolumeFluent.HostPathNested<A> withNewHostPathLike(HostPathVolumeSource item)

editHostPath

public VolumeFluent.HostPathNested<A> editHostPath()

editOrNewHostPath

public VolumeFluent.HostPathNested<A> editOrNewHostPath()

editOrNewHostPathLike

public VolumeFluent.HostPathNested<A> editOrNewHostPathLike(HostPathVolumeSource item)

buildIscsi
```
public ISCSIVolumeSource buildIscsi()
```

withIscsi

public A withIscsi(ISCSIVolumeSource iscsi)

hasIscsi
```
public boolean hasIscsi()
```

withNewIscsi

public VolumeFluent.IscsiNested<A> withNewIscsi()

withNewIscsiLike

public VolumeFluent.IscsiNested<A> withNewIscsiLike(ISCSIVolumeSource item)

editIscsi

public VolumeFluent.IscsiNested<A> editIscsi()

editOrNewIscsi

public VolumeFluent.IscsiNested<A> editOrNewIscsi()

editOrNewIscsiLike

public VolumeFluent.IscsiNested<A> editOrNewIscsiLike(ISCSIVolumeSource item)

getName
```
public String getName()
```

withName
```
public A withName(String name)
```

hasName
```
public boolean hasName()
```

buildNfs
```
public NFSVolumeSource buildNfs()
```

withNfs

public A withNfs(NFSVolumeSource nfs)

hasNfs
```
public boolean hasNfs()
```

withNewNfs

public A withNewNfs(String path,
                    Boolean readOnly,
                    String server)

withNewNfs

public VolumeFluent.NfsNested<A> withNewNfs()

withNewNfsLike

public VolumeFluent.NfsNested<A> withNewNfsLike(NFSVolumeSource item)

editNfs

public VolumeFluent.NfsNested<A> editNfs()

editOrNewNfs

public VolumeFluent.NfsNested<A> editOrNewNfs()

editOrNewNfsLike

public VolumeFluent.NfsNested<A> editOrNewNfsLike(NFSVolumeSource item)

buildPersistentVolumeClaim

public PersistentVolumeClaimVolumeSource buildPersistentVolumeClaim()

withPersistentVolumeClaim

public A withPersistentVolumeClaim(PersistentVolumeClaimVolumeSource persistentVolumeClaim)

hasPersistentVolumeClaim

public boolean hasPersistentVolumeClaim()

withNewPersistentVolumeClaim

public A withNewPersistentVolumeClaim(String claimName,
                                      Boolean readOnly)

withNewPersistentVolumeClaim

public VolumeFluent.PersistentVolumeClaimNested<A> withNewPersistentVolumeClaim()

withNewPersistentVolumeClaimLike

public VolumeFluent.PersistentVolumeClaimNested<A> withNewPersistentVolumeClaimLike(PersistentVolumeClaimVolumeSource item)

editPersistentVolumeClaim

public VolumeFluent.PersistentVolumeClaimNested<A> editPersistentVolumeClaim()

editOrNewPersistentVolumeClaim

public VolumeFluent.PersistentVolumeClaimNested<A> editOrNewPersistentVolumeClaim()

editOrNewPersistentVolumeClaimLike

public VolumeFluent.PersistentVolumeClaimNested<A> editOrNewPersistentVolumeClaimLike(PersistentVolumeClaimVolumeSource item)

buildPhotonPersistentDisk

public PhotonPersistentDiskVolumeSource buildPhotonPersistentDisk()

withPhotonPersistentDisk

public A withPhotonPersistentDisk(PhotonPersistentDiskVolumeSource photonPersistentDisk)

hasPhotonPersistentDisk

public boolean hasPhotonPersistentDisk()

withNewPhotonPersistentDisk

public A withNewPhotonPersistentDisk(String fsType,
                                     String pdID)

withNewPhotonPersistentDisk

public VolumeFluent.PhotonPersistentDiskNested<A> withNewPhotonPersistentDisk()

withNewPhotonPersistentDiskLike

public VolumeFluent.PhotonPersistentDiskNested<A> withNewPhotonPersistentDiskLike(PhotonPersistentDiskVolumeSource item)

editPhotonPersistentDisk

public VolumeFluent.PhotonPersistentDiskNested<A> editPhotonPersistentDisk()

editOrNewPhotonPersistentDisk

public VolumeFluent.PhotonPersistentDiskNested<A> editOrNewPhotonPersistentDisk()

editOrNewPhotonPersistentDiskLike

public VolumeFluent.PhotonPersistentDiskNested<A> editOrNewPhotonPersistentDiskLike(PhotonPersistentDiskVolumeSource item)

buildPortworxVolume

public PortworxVolumeSource buildPortworxVolume()

withPortworxVolume

public A withPortworxVolume(PortworxVolumeSource portworxVolume)

hasPortworxVolume
```
public boolean hasPortworxVolume()
```

withNewPortworxVolume

public A withNewPortworxVolume(String fsType,
                               Boolean readOnly,
                               String volumeID)

withNewPortworxVolume

public VolumeFluent.PortworxVolumeNested<A> withNewPortworxVolume()

withNewPortworxVolumeLike

public VolumeFluent.PortworxVolumeNested<A> withNewPortworxVolumeLike(PortworxVolumeSource item)

editPortworxVolume

public VolumeFluent.PortworxVolumeNested<A> editPortworxVolume()

editOrNewPortworxVolume

public VolumeFluent.PortworxVolumeNested<A> editOrNewPortworxVolume()

editOrNewPortworxVolumeLike

public VolumeFluent.PortworxVolumeNested<A> editOrNewPortworxVolumeLike(PortworxVolumeSource item)

buildProjected

public ProjectedVolumeSource buildProjected()

withProjected

public A withProjected(ProjectedVolumeSource projected)

hasProjected
```
public boolean hasProjected()
```

withNewProjected

public VolumeFluent.ProjectedNested<A> withNewProjected()

withNewProjectedLike

public VolumeFluent.ProjectedNested<A> withNewProjectedLike(ProjectedVolumeSource item)

editProjected

public VolumeFluent.ProjectedNested<A> editProjected()

editOrNewProjected

public VolumeFluent.ProjectedNested<A> editOrNewProjected()

editOrNewProjectedLike

public VolumeFluent.ProjectedNested<A> editOrNewProjectedLike(ProjectedVolumeSource item)

buildQuobyte

public QuobyteVolumeSource buildQuobyte()

withQuobyte

public A withQuobyte(QuobyteVolumeSource quobyte)

hasQuobyte
```
public boolean hasQuobyte()
```

withNewQuobyte

public VolumeFluent.QuobyteNested<A> withNewQuobyte()

withNewQuobyteLike

public VolumeFluent.QuobyteNested<A> withNewQuobyteLike(QuobyteVolumeSource item)

editQuobyte

public VolumeFluent.QuobyteNested<A> editQuobyte()

editOrNewQuobyte

public VolumeFluent.QuobyteNested<A> editOrNewQuobyte()

editOrNewQuobyteLike

public VolumeFluent.QuobyteNested<A> editOrNewQuobyteLike(QuobyteVolumeSource item)

buildRbd
```
public RBDVolumeSource buildRbd()
```

withRbd

public A withRbd(RBDVolumeSource rbd)

hasRbd
```
public boolean hasRbd()
```

withNewRbd

public VolumeFluent.RbdNested<A> withNewRbd()

withNewRbdLike

public VolumeFluent.RbdNested<A> withNewRbdLike(RBDVolumeSource item)

editRbd

public VolumeFluent.RbdNested<A> editRbd()

editOrNewRbd

public VolumeFluent.RbdNested<A> editOrNewRbd()

editOrNewRbdLike

public VolumeFluent.RbdNested<A> editOrNewRbdLike(RBDVolumeSource item)

buildScaleIO

public ScaleIOVolumeSource buildScaleIO()

withScaleIO

public A withScaleIO(ScaleIOVolumeSource scaleIO)

hasScaleIO
```
public boolean hasScaleIO()
```

withNewScaleIO

public VolumeFluent.ScaleIONested<A> withNewScaleIO()

withNewScaleIOLike

public VolumeFluent.ScaleIONested<A> withNewScaleIOLike(ScaleIOVolumeSource item)

editScaleIO

public VolumeFluent.ScaleIONested<A> editScaleIO()

editOrNewScaleIO

public VolumeFluent.ScaleIONested<A> editOrNewScaleIO()

editOrNewScaleIOLike

public VolumeFluent.ScaleIONested<A> editOrNewScaleIOLike(ScaleIOVolumeSource item)

buildSecret

public SecretVolumeSource buildSecret()

withSecret

public A withSecret(SecretVolumeSource secret)

hasSecret
```
public boolean hasSecret()
```

withNewSecret

public VolumeFluent.SecretNested<A> withNewSecret()

withNewSecretLike

public VolumeFluent.SecretNested<A> withNewSecretLike(SecretVolumeSource item)

editSecret

public VolumeFluent.SecretNested<A> editSecret()

editOrNewSecret

public VolumeFluent.SecretNested<A> editOrNewSecret()

editOrNewSecretLike

public VolumeFluent.SecretNested<A> editOrNewSecretLike(SecretVolumeSource item)

buildStorageos

public StorageOSVolumeSource buildStorageos()

withStorageos

public A withStorageos(StorageOSVolumeSource storageos)

hasStorageos
```
public boolean hasStorageos()
```

withNewStorageos

public VolumeFluent.StorageosNested<A> withNewStorageos()

withNewStorageosLike

public VolumeFluent.StorageosNested<A> withNewStorageosLike(StorageOSVolumeSource item)

editStorageos

public VolumeFluent.StorageosNested<A> editStorageos()

editOrNewStorageos

public VolumeFluent.StorageosNested<A> editOrNewStorageos()

editOrNewStorageosLike

public VolumeFluent.StorageosNested<A> editOrNewStorageosLike(StorageOSVolumeSource item)

buildVsphereVolume

public VsphereVirtualDiskVolumeSource buildVsphereVolume()

withVsphereVolume

public A withVsphereVolume(VsphereVirtualDiskVolumeSource vsphereVolume)

hasVsphereVolume
```
public boolean hasVsphereVolume()
```

withNewVsphereVolume

public A withNewVsphereVolume(String fsType,
                              String storagePolicyID,
                              String storagePolicyName,
                              String volumePath)

withNewVsphereVolume

public VolumeFluent.VsphereVolumeNested<A> withNewVsphereVolume()

withNewVsphereVolumeLike

public VolumeFluent.VsphereVolumeNested<A> withNewVsphereVolumeLike(VsphereVirtualDiskVolumeSource item)

editVsphereVolume

public VolumeFluent.VsphereVolumeNested<A> editVsphereVolume()

editOrNewVsphereVolume

public VolumeFluent.VsphereVolumeNested<A> editOrNewVsphereVolume()

editOrNewVsphereVolumeLike

public VolumeFluent.VsphereVolumeNested<A> editOrNewVsphereVolumeLike(VsphereVirtualDiskVolumeSource item)

addToAdditionalProperties

public A addToAdditionalProperties(String key,
                                   Object value)

addToAdditionalProperties

public A addToAdditionalProperties(Map<String,Object> map)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(String key)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(Map<String,Object> map)

getAdditionalProperties

public Map<String,Object> getAdditionalProperties()

withAdditionalProperties

public <K,V> A withAdditionalProperties(Map<String,Object> additionalProperties)

hasAdditionalProperties

public boolean hasAdditionalProperties()

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends VolumeFluent<A>>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends VolumeFluent<A>>

toString
```
public String toString()
```
Overrides:

toString in class Object

Class VolumeFluent<A extends VolumeFluent<A>>

Nested Class Summary

Field Summary

Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Detail

VolumeFluent

VolumeFluent

Method Detail

copyInstance

buildAwsElasticBlockStore

withAwsElasticBlockStore

hasAwsElasticBlockStore

withNewAwsElasticBlockStore

withNewAwsElasticBlockStore

withNewAwsElasticBlockStoreLike

editAwsElasticBlockStore

editOrNewAwsElasticBlockStore

editOrNewAwsElasticBlockStoreLike

buildAzureDisk

withAzureDisk

hasAzureDisk

withNewAzureDisk

withNewAzureDiskLike

editAzureDisk

editOrNewAzureDisk

editOrNewAzureDiskLike

buildAzureFile

withAzureFile

hasAzureFile

withNewAzureFile

withNewAzureFile

withNewAzureFileLike

editAzureFile

editOrNewAzureFile

editOrNewAzureFileLike

buildCephfs

withCephfs

hasCephfs

withNewCephfs

withNewCephfsLike

editCephfs

editOrNewCephfs

editOrNewCephfsLike

buildCinder

withCinder

hasCinder

withNewCinder

withNewCinderLike

editCinder

editOrNewCinder

editOrNewCinderLike

buildConfigMap

withConfigMap

hasConfigMap

withNewConfigMap

withNewConfigMapLike

editConfigMap

editOrNewConfigMap

editOrNewConfigMapLike

buildCsi

withCsi

hasCsi

withNewCsi

withNewCsiLike

editCsi

editOrNewCsi

editOrNewCsiLike

buildDownwardAPI

withDownwardAPI

hasDownwardAPI

withNewDownwardAPI

withNewDownwardAPILike

editDownwardAPI

editOrNewDownwardAPI

editOrNewDownwardAPILike

buildEmptyDir