java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.apicurio.registry.operator.api.v1.model.apicurioregistryspec.deployment.podtemplatespecpreview.spec.VolumesFluent<A>

All Implemented Interfaces:

io.fabric8.kubernetes.api.builder.Fluent<A>, io.fabric8.kubernetes.api.builder.Visitable<A>

Direct Known Subclasses:

SpecFluent.VolumesNested, VolumesBuilder
```
public class VolumesFluent<A extends VolumesFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

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

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

Constructor Summary

Constructors
Constructor Description

VolumesFluent()

VolumesFluent(Volumes instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`AwsElasticBlockStore`	`buildAwsElasticBlockStore()`
`AzureDisk`	`buildAzureDisk()`
`AzureFile`	`buildAzureFile()`
`Cephfs`	`buildCephfs()`
`Cinder`	`buildCinder()`
`ConfigMap`	`buildConfigMap()`
`Csi`	`buildCsi()`
`DownwardAPI`	`buildDownwardAPI()`
`EmptyDir`	`buildEmptyDir()`
`Ephemeral`	`buildEphemeral()`
`Fc`	`buildFc()`
`FlexVolume`	`buildFlexVolume()`
`Flocker`	`buildFlocker()`
`GcePersistentDisk`	`buildGcePersistentDisk()`
`GitRepo`	`buildGitRepo()`
`Glusterfs`	`buildGlusterfs()`
`HostPath`	`buildHostPath()`
`Iscsi`	`buildIscsi()`
`Nfs`	`buildNfs()`
`PersistentVolumeClaim`	`buildPersistentVolumeClaim()`
`PhotonPersistentDisk`	`buildPhotonPersistentDisk()`
`PortworxVolume`	`buildPortworxVolume()`
`Projected`	`buildProjected()`
`Quobyte`	`buildQuobyte()`
`Rbd`	`buildRbd()`
`ScaleIO`	`buildScaleIO()`
`Secret`	`buildSecret()`
`Storageos`	`buildStorageos()`
`VsphereVolume`	`buildVsphereVolume()`
`VolumesFluent.AwsElasticBlockStoreNested<A>`	`editAwsElasticBlockStore()`
`VolumesFluent.AzureDiskNested<A>`	`editAzureDisk()`
`VolumesFluent.AzureFileNested<A>`	`editAzureFile()`
`VolumesFluent.CephfsNested<A>`	`editCephfs()`
`VolumesFluent.CinderNested<A>`	`editCinder()`
`VolumesFluent.ConfigMapNested<A>`	`editConfigMap()`
`VolumesFluent.CsiNested<A>`	`editCsi()`
`VolumesFluent.DownwardAPINested<A>`	`editDownwardAPI()`
`VolumesFluent.EmptyDirNested<A>`	`editEmptyDir()`
`VolumesFluent.EphemeralNested<A>`	`editEphemeral()`
`VolumesFluent.FcNested<A>`	`editFc()`
`VolumesFluent.FlexVolumeNested<A>`	`editFlexVolume()`
`VolumesFluent.FlockerNested<A>`	`editFlocker()`
`VolumesFluent.GcePersistentDiskNested<A>`	`editGcePersistentDisk()`
`VolumesFluent.GitRepoNested<A>`	`editGitRepo()`
`VolumesFluent.GlusterfsNested<A>`	`editGlusterfs()`
`VolumesFluent.HostPathNested<A>`	`editHostPath()`
`VolumesFluent.IscsiNested<A>`	`editIscsi()`
`VolumesFluent.NfsNested<A>`	`editNfs()`
`VolumesFluent.AwsElasticBlockStoreNested<A>`	`editOrNewAwsElasticBlockStore()`
`VolumesFluent.AwsElasticBlockStoreNested<A>`	`editOrNewAwsElasticBlockStoreLike(AwsElasticBlockStore item)`
`VolumesFluent.AzureDiskNested<A>`	`editOrNewAzureDisk()`
`VolumesFluent.AzureDiskNested<A>`	`editOrNewAzureDiskLike(AzureDisk item)`
`VolumesFluent.AzureFileNested<A>`	`editOrNewAzureFile()`
`VolumesFluent.AzureFileNested<A>`	`editOrNewAzureFileLike(AzureFile item)`
`VolumesFluent.CephfsNested<A>`	`editOrNewCephfs()`
`VolumesFluent.CephfsNested<A>`	`editOrNewCephfsLike(Cephfs item)`
`VolumesFluent.CinderNested<A>`	`editOrNewCinder()`
`VolumesFluent.CinderNested<A>`	`editOrNewCinderLike(Cinder item)`
`VolumesFluent.ConfigMapNested<A>`	`editOrNewConfigMap()`
`VolumesFluent.ConfigMapNested<A>`	`editOrNewConfigMapLike(ConfigMap item)`
`VolumesFluent.CsiNested<A>`	`editOrNewCsi()`
`VolumesFluent.CsiNested<A>`	`editOrNewCsiLike(Csi item)`
`VolumesFluent.DownwardAPINested<A>`	`editOrNewDownwardAPI()`
`VolumesFluent.DownwardAPINested<A>`	`editOrNewDownwardAPILike(DownwardAPI item)`
`VolumesFluent.EmptyDirNested<A>`	`editOrNewEmptyDir()`
`VolumesFluent.EmptyDirNested<A>`	`editOrNewEmptyDirLike(EmptyDir item)`
`VolumesFluent.EphemeralNested<A>`	`editOrNewEphemeral()`
`VolumesFluent.EphemeralNested<A>`	`editOrNewEphemeralLike(Ephemeral item)`
`VolumesFluent.FcNested<A>`	`editOrNewFc()`
`VolumesFluent.FcNested<A>`	`editOrNewFcLike(Fc item)`
`VolumesFluent.FlexVolumeNested<A>`	`editOrNewFlexVolume()`
`VolumesFluent.FlexVolumeNested<A>`	`editOrNewFlexVolumeLike(FlexVolume item)`
`VolumesFluent.FlockerNested<A>`	`editOrNewFlocker()`
`VolumesFluent.FlockerNested<A>`	`editOrNewFlockerLike(Flocker item)`
`VolumesFluent.GcePersistentDiskNested<A>`	`editOrNewGcePersistentDisk()`
`VolumesFluent.GcePersistentDiskNested<A>`	`editOrNewGcePersistentDiskLike(GcePersistentDisk item)`
`VolumesFluent.GitRepoNested<A>`	`editOrNewGitRepo()`
`VolumesFluent.GitRepoNested<A>`	`editOrNewGitRepoLike(GitRepo item)`
`VolumesFluent.GlusterfsNested<A>`	`editOrNewGlusterfs()`
`VolumesFluent.GlusterfsNested<A>`	`editOrNewGlusterfsLike(Glusterfs item)`
`VolumesFluent.HostPathNested<A>`	`editOrNewHostPath()`
`VolumesFluent.HostPathNested<A>`	`editOrNewHostPathLike(HostPath item)`
`VolumesFluent.IscsiNested<A>`	`editOrNewIscsi()`
`VolumesFluent.IscsiNested<A>`	`editOrNewIscsiLike(Iscsi item)`
`VolumesFluent.NfsNested<A>`	`editOrNewNfs()`
`VolumesFluent.NfsNested<A>`	`editOrNewNfsLike(Nfs item)`
`VolumesFluent.PersistentVolumeClaimNested<A>`	`editOrNewPersistentVolumeClaim()`
`VolumesFluent.PersistentVolumeClaimNested<A>`	`editOrNewPersistentVolumeClaimLike(PersistentVolumeClaim item)`
`VolumesFluent.PhotonPersistentDiskNested<A>`	`editOrNewPhotonPersistentDisk()`
`VolumesFluent.PhotonPersistentDiskNested<A>`	`editOrNewPhotonPersistentDiskLike(PhotonPersistentDisk item)`
`VolumesFluent.PortworxVolumeNested<A>`	`editOrNewPortworxVolume()`
`VolumesFluent.PortworxVolumeNested<A>`	`editOrNewPortworxVolumeLike(PortworxVolume item)`
`VolumesFluent.ProjectedNested<A>`	`editOrNewProjected()`
`VolumesFluent.ProjectedNested<A>`	`editOrNewProjectedLike(Projected item)`
`VolumesFluent.QuobyteNested<A>`	`editOrNewQuobyte()`
`VolumesFluent.QuobyteNested<A>`	`editOrNewQuobyteLike(Quobyte item)`
`VolumesFluent.RbdNested<A>`	`editOrNewRbd()`
`VolumesFluent.RbdNested<A>`	`editOrNewRbdLike(Rbd item)`
`VolumesFluent.ScaleIONested<A>`	`editOrNewScaleIO()`
`VolumesFluent.ScaleIONested<A>`	`editOrNewScaleIOLike(ScaleIO item)`
`VolumesFluent.SecretNested<A>`	`editOrNewSecret()`
`VolumesFluent.SecretNested<A>`	`editOrNewSecretLike(Secret item)`
`VolumesFluent.StorageosNested<A>`	`editOrNewStorageos()`
`VolumesFluent.StorageosNested<A>`	`editOrNewStorageosLike(Storageos item)`
`VolumesFluent.VsphereVolumeNested<A>`	`editOrNewVsphereVolume()`
`VolumesFluent.VsphereVolumeNested<A>`	`editOrNewVsphereVolumeLike(VsphereVolume item)`
`VolumesFluent.PersistentVolumeClaimNested<A>`	`editPersistentVolumeClaim()`
`VolumesFluent.PhotonPersistentDiskNested<A>`	`editPhotonPersistentDisk()`
`VolumesFluent.PortworxVolumeNested<A>`	`editPortworxVolume()`
`VolumesFluent.ProjectedNested<A>`	`editProjected()`
`VolumesFluent.QuobyteNested<A>`	`editQuobyte()`
`VolumesFluent.RbdNested<A>`	`editRbd()`
`VolumesFluent.ScaleIONested<A>`	`editScaleIO()`
`VolumesFluent.SecretNested<A>`	`editSecret()`
`VolumesFluent.StorageosNested<A>`	`editStorageos()`
`VolumesFluent.VsphereVolumeNested<A>`	`editVsphereVolume()`
`boolean`	`equals(Object o)`
`String`	`getName()`
`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()`
`String`	`toString()`
`A`	`withAwsElasticBlockStore(AwsElasticBlockStore awsElasticBlockStore)`
`A`	`withAzureDisk(AzureDisk azureDisk)`
`A`	`withAzureFile(AzureFile azureFile)`
`A`	`withCephfs(Cephfs cephfs)`
`A`	`withCinder(Cinder cinder)`
`A`	`withConfigMap(ConfigMap configMap)`
`A`	`withCsi(Csi csi)`
`A`	`withDownwardAPI(DownwardAPI downwardAPI)`
`A`	`withEmptyDir(EmptyDir emptyDir)`
`A`	`withEphemeral(Ephemeral ephemeral)`
`A`	`withFc(Fc fc)`
`A`	`withFlexVolume(FlexVolume flexVolume)`
`A`	`withFlocker(Flocker flocker)`
`A`	`withGcePersistentDisk(GcePersistentDisk gcePersistentDisk)`
`A`	`withGitRepo(GitRepo gitRepo)`
`A`	`withGlusterfs(Glusterfs glusterfs)`
`A`	`withHostPath(HostPath hostPath)`
`A`	`withIscsi(Iscsi iscsi)`
`A`	`withName(String name)`
`VolumesFluent.AwsElasticBlockStoreNested<A>`	`withNewAwsElasticBlockStore()`
`VolumesFluent.AwsElasticBlockStoreNested<A>`	`withNewAwsElasticBlockStoreLike(AwsElasticBlockStore item)`
`VolumesFluent.AzureDiskNested<A>`	`withNewAzureDisk()`
`VolumesFluent.AzureDiskNested<A>`	`withNewAzureDiskLike(AzureDisk item)`
`VolumesFluent.AzureFileNested<A>`	`withNewAzureFile()`
`VolumesFluent.AzureFileNested<A>`	`withNewAzureFileLike(AzureFile item)`
`VolumesFluent.CephfsNested<A>`	`withNewCephfs()`
`VolumesFluent.CephfsNested<A>`	`withNewCephfsLike(Cephfs item)`
`VolumesFluent.CinderNested<A>`	`withNewCinder()`
`VolumesFluent.CinderNested<A>`	`withNewCinderLike(Cinder item)`
`VolumesFluent.ConfigMapNested<A>`	`withNewConfigMap()`
`VolumesFluent.ConfigMapNested<A>`	`withNewConfigMapLike(ConfigMap item)`
`VolumesFluent.CsiNested<A>`	`withNewCsi()`
`VolumesFluent.CsiNested<A>`	`withNewCsiLike(Csi item)`
`VolumesFluent.DownwardAPINested<A>`	`withNewDownwardAPI()`
`VolumesFluent.DownwardAPINested<A>`	`withNewDownwardAPILike(DownwardAPI item)`
`VolumesFluent.EmptyDirNested<A>`	`withNewEmptyDir()`
`VolumesFluent.EmptyDirNested<A>`	`withNewEmptyDirLike(EmptyDir item)`
`VolumesFluent.EphemeralNested<A>`	`withNewEphemeral()`
`VolumesFluent.EphemeralNested<A>`	`withNewEphemeralLike(Ephemeral item)`
`VolumesFluent.FcNested<A>`	`withNewFc()`
`VolumesFluent.FcNested<A>`	`withNewFcLike(Fc item)`
`VolumesFluent.FlexVolumeNested<A>`	`withNewFlexVolume()`
`VolumesFluent.FlexVolumeNested<A>`	`withNewFlexVolumeLike(FlexVolume item)`
`VolumesFluent.FlockerNested<A>`	`withNewFlocker()`
`VolumesFluent.FlockerNested<A>`	`withNewFlockerLike(Flocker item)`
`VolumesFluent.GcePersistentDiskNested<A>`	`withNewGcePersistentDisk()`
`VolumesFluent.GcePersistentDiskNested<A>`	`withNewGcePersistentDiskLike(GcePersistentDisk item)`
`VolumesFluent.GitRepoNested<A>`	`withNewGitRepo()`
`VolumesFluent.GitRepoNested<A>`	`withNewGitRepoLike(GitRepo item)`
`VolumesFluent.GlusterfsNested<A>`	`withNewGlusterfs()`
`VolumesFluent.GlusterfsNested<A>`	`withNewGlusterfsLike(Glusterfs item)`
`VolumesFluent.HostPathNested<A>`	`withNewHostPath()`
`VolumesFluent.HostPathNested<A>`	`withNewHostPathLike(HostPath item)`
`VolumesFluent.IscsiNested<A>`	`withNewIscsi()`
`VolumesFluent.IscsiNested<A>`	`withNewIscsiLike(Iscsi item)`
`VolumesFluent.NfsNested<A>`	`withNewNfs()`
`VolumesFluent.NfsNested<A>`	`withNewNfsLike(Nfs item)`
`VolumesFluent.PersistentVolumeClaimNested<A>`	`withNewPersistentVolumeClaim()`
`VolumesFluent.PersistentVolumeClaimNested<A>`	`withNewPersistentVolumeClaimLike(PersistentVolumeClaim item)`
`VolumesFluent.PhotonPersistentDiskNested<A>`	`withNewPhotonPersistentDisk()`
`VolumesFluent.PhotonPersistentDiskNested<A>`	`withNewPhotonPersistentDiskLike(PhotonPersistentDisk item)`
`VolumesFluent.PortworxVolumeNested<A>`	`withNewPortworxVolume()`
`VolumesFluent.PortworxVolumeNested<A>`	`withNewPortworxVolumeLike(PortworxVolume item)`
`VolumesFluent.ProjectedNested<A>`	`withNewProjected()`
`VolumesFluent.ProjectedNested<A>`	`withNewProjectedLike(Projected item)`
`VolumesFluent.QuobyteNested<A>`	`withNewQuobyte()`
`VolumesFluent.QuobyteNested<A>`	`withNewQuobyteLike(Quobyte item)`
`VolumesFluent.RbdNested<A>`	`withNewRbd()`
`VolumesFluent.RbdNested<A>`	`withNewRbdLike(Rbd item)`
`VolumesFluent.ScaleIONested<A>`	`withNewScaleIO()`
`VolumesFluent.ScaleIONested<A>`	`withNewScaleIOLike(ScaleIO item)`
`VolumesFluent.SecretNested<A>`	`withNewSecret()`
`VolumesFluent.SecretNested<A>`	`withNewSecretLike(Secret item)`
`VolumesFluent.StorageosNested<A>`	`withNewStorageos()`
`VolumesFluent.StorageosNested<A>`	`withNewStorageosLike(Storageos item)`
`VolumesFluent.VsphereVolumeNested<A>`	`withNewVsphereVolume()`
`VolumesFluent.VsphereVolumeNested<A>`	`withNewVsphereVolumeLike(VsphereVolume item)`
`A`	`withNfs(Nfs nfs)`
`A`	`withPersistentVolumeClaim(PersistentVolumeClaim persistentVolumeClaim)`
`A`	`withPhotonPersistentDisk(PhotonPersistentDisk photonPersistentDisk)`
`A`	`withPortworxVolume(PortworxVolume portworxVolume)`
`A`	`withProjected(Projected projected)`
`A`	`withQuobyte(Quobyte quobyte)`
`A`	`withRbd(Rbd rbd)`
`A`	`withScaleIO(ScaleIO scaleIO)`
`A`	`withSecret(Secret secret)`
`A`	`withStorageos(Storageos storageos)`
`A`	`withVsphereVolume(VsphereVolume vsphereVolume)`

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

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

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable
getTarget

Constructor Detail

VolumesFluent
```
public VolumesFluent()
```

VolumesFluent

public VolumesFluent(Volumes instance)

Method Detail

buildAwsElasticBlockStore

public AwsElasticBlockStore buildAwsElasticBlockStore()

withAwsElasticBlockStore

public A withAwsElasticBlockStore(AwsElasticBlockStore awsElasticBlockStore)

hasAwsElasticBlockStore

public boolean hasAwsElasticBlockStore()

withNewAwsElasticBlockStore

public VolumesFluent.AwsElasticBlockStoreNested<A> withNewAwsElasticBlockStore()

withNewAwsElasticBlockStoreLike

public VolumesFluent.AwsElasticBlockStoreNested<A> withNewAwsElasticBlockStoreLike(AwsElasticBlockStore item)

editAwsElasticBlockStore

public VolumesFluent.AwsElasticBlockStoreNested<A> editAwsElasticBlockStore()

editOrNewAwsElasticBlockStore

public VolumesFluent.AwsElasticBlockStoreNested<A> editOrNewAwsElasticBlockStore()

editOrNewAwsElasticBlockStoreLike

public VolumesFluent.AwsElasticBlockStoreNested<A> editOrNewAwsElasticBlockStoreLike(AwsElasticBlockStore item)

buildAzureDisk
```
public AzureDisk buildAzureDisk()
```

withAzureDisk

public A withAzureDisk(AzureDisk azureDisk)

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

withNewAzureDisk

public VolumesFluent.AzureDiskNested<A> withNewAzureDisk()

withNewAzureDiskLike

public VolumesFluent.AzureDiskNested<A> withNewAzureDiskLike(AzureDisk item)

editAzureDisk

public VolumesFluent.AzureDiskNested<A> editAzureDisk()

editOrNewAzureDisk

public VolumesFluent.AzureDiskNested<A> editOrNewAzureDisk()

editOrNewAzureDiskLike

public VolumesFluent.AzureDiskNested<A> editOrNewAzureDiskLike(AzureDisk item)

buildAzureFile
```
public AzureFile buildAzureFile()
```

withAzureFile

public A withAzureFile(AzureFile azureFile)

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

withNewAzureFile

public VolumesFluent.AzureFileNested<A> withNewAzureFile()

withNewAzureFileLike

public VolumesFluent.AzureFileNested<A> withNewAzureFileLike(AzureFile item)

editAzureFile

public VolumesFluent.AzureFileNested<A> editAzureFile()

editOrNewAzureFile

public VolumesFluent.AzureFileNested<A> editOrNewAzureFile()

editOrNewAzureFileLike

public VolumesFluent.AzureFileNested<A> editOrNewAzureFileLike(AzureFile item)

buildCephfs
```
public Cephfs buildCephfs()
```

withCephfs

public A withCephfs(Cephfs cephfs)

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

withNewCephfs

public VolumesFluent.CephfsNested<A> withNewCephfs()

withNewCephfsLike

public VolumesFluent.CephfsNested<A> withNewCephfsLike(Cephfs item)

editCephfs

public VolumesFluent.CephfsNested<A> editCephfs()

editOrNewCephfs

public VolumesFluent.CephfsNested<A> editOrNewCephfs()

editOrNewCephfsLike

public VolumesFluent.CephfsNested<A> editOrNewCephfsLike(Cephfs item)

buildCinder
```
public Cinder buildCinder()
```

withCinder

public A withCinder(Cinder cinder)

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

withNewCinder

public VolumesFluent.CinderNested<A> withNewCinder()

withNewCinderLike

public VolumesFluent.CinderNested<A> withNewCinderLike(Cinder item)

editCinder

public VolumesFluent.CinderNested<A> editCinder()

editOrNewCinder

public VolumesFluent.CinderNested<A> editOrNewCinder()

editOrNewCinderLike

public VolumesFluent.CinderNested<A> editOrNewCinderLike(Cinder item)

buildConfigMap
```
public ConfigMap buildConfigMap()
```

withConfigMap

public A withConfigMap(ConfigMap configMap)

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

withNewConfigMap

public VolumesFluent.ConfigMapNested<A> withNewConfigMap()

withNewConfigMapLike

public VolumesFluent.ConfigMapNested<A> withNewConfigMapLike(ConfigMap item)

editConfigMap

public VolumesFluent.ConfigMapNested<A> editConfigMap()

editOrNewConfigMap

public VolumesFluent.ConfigMapNested<A> editOrNewConfigMap()

editOrNewConfigMapLike

public VolumesFluent.ConfigMapNested<A> editOrNewConfigMapLike(ConfigMap item)

buildCsi
```
public Csi buildCsi()
```

withCsi
```
public A withCsi(Csi csi)
```

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

withNewCsi

public VolumesFluent.CsiNested<A> withNewCsi()

withNewCsiLike

public VolumesFluent.CsiNested<A> withNewCsiLike(Csi item)

editCsi

public VolumesFluent.CsiNested<A> editCsi()

editOrNewCsi

public VolumesFluent.CsiNested<A> editOrNewCsi()

editOrNewCsiLike

public VolumesFluent.CsiNested<A> editOrNewCsiLike(Csi item)

buildDownwardAPI
```
public DownwardAPI buildDownwardAPI()
```

withDownwardAPI

public A withDownwardAPI(DownwardAPI downwardAPI)

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

withNewDownwardAPI

public VolumesFluent.DownwardAPINested<A> withNewDownwardAPI()

withNewDownwardAPILike

public VolumesFluent.DownwardAPINested<A> withNewDownwardAPILike(DownwardAPI item)

editDownwardAPI

public VolumesFluent.DownwardAPINested<A> editDownwardAPI()

editOrNewDownwardAPI

public VolumesFluent.DownwardAPINested<A> editOrNewDownwardAPI()

editOrNewDownwardAPILike

public VolumesFluent.DownwardAPINested<A> editOrNewDownwardAPILike(DownwardAPI item)

buildEmptyDir
```
public EmptyDir buildEmptyDir()
```

withEmptyDir

public A withEmptyDir(EmptyDir emptyDir)

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

withNewEmptyDir

public VolumesFluent.EmptyDirNested<A> withNewEmptyDir()

withNewEmptyDirLike

public VolumesFluent.EmptyDirNested<A> withNewEmptyDirLike(EmptyDir item)

editEmptyDir

public VolumesFluent.EmptyDirNested<A> editEmptyDir()

editOrNewEmptyDir

public VolumesFluent.EmptyDirNested<A> editOrNewEmptyDir()

editOrNewEmptyDirLike

public VolumesFluent.EmptyDirNested<A> editOrNewEmptyDirLike(EmptyDir item)

buildEphemeral
```
public Ephemeral buildEphemeral()
```

withEphemeral

public A withEphemeral(Ephemeral ephemeral)

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

withNewEphemeral

public VolumesFluent.EphemeralNested<A> withNewEphemeral()

withNewEphemeralLike

public VolumesFluent.EphemeralNested<A> withNewEphemeralLike(Ephemeral item)

editEphemeral

public VolumesFluent.EphemeralNested<A> editEphemeral()

editOrNewEphemeral

public VolumesFluent.EphemeralNested<A> editOrNewEphemeral()

editOrNewEphemeralLike

public VolumesFluent.EphemeralNested<A> editOrNewEphemeralLike(Ephemeral item)

buildFc
```
public Fc buildFc()
```

withFc
```
public A withFc(Fc fc)
```

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

withNewFc

public VolumesFluent.FcNested<A> withNewFc()

withNewFcLike

public VolumesFluent.FcNested<A> withNewFcLike(Fc item)

editFc

public VolumesFluent.FcNested<A> editFc()

editOrNewFc

public VolumesFluent.FcNested<A> editOrNewFc()

editOrNewFcLike

public VolumesFluent.FcNested<A> editOrNewFcLike(Fc item)

buildFlexVolume
```
public FlexVolume buildFlexVolume()
```

withFlexVolume

public A withFlexVolume(FlexVolume flexVolume)

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

withNewFlexVolume

public VolumesFluent.FlexVolumeNested<A> withNewFlexVolume()

withNewFlexVolumeLike

public VolumesFluent.FlexVolumeNested<A> withNewFlexVolumeLike(FlexVolume item)

editFlexVolume

public VolumesFluent.FlexVolumeNested<A> editFlexVolume()

editOrNewFlexVolume

public VolumesFluent.FlexVolumeNested<A> editOrNewFlexVolume()

editOrNewFlexVolumeLike

public VolumesFluent.FlexVolumeNested<A> editOrNewFlexVolumeLike(FlexVolume item)

buildFlocker
```
public Flocker buildFlocker()
```

withFlocker

public A withFlocker(Flocker flocker)

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

withNewFlocker

public VolumesFluent.FlockerNested<A> withNewFlocker()

withNewFlockerLike

public VolumesFluent.FlockerNested<A> withNewFlockerLike(Flocker item)

editFlocker

public VolumesFluent.FlockerNested<A> editFlocker()

editOrNewFlocker

public VolumesFluent.FlockerNested<A> editOrNewFlocker()

editOrNewFlockerLike

public VolumesFluent.FlockerNested<A> editOrNewFlockerLike(Flocker item)

buildGcePersistentDisk

public GcePersistentDisk buildGcePersistentDisk()

withGcePersistentDisk

public A withGcePersistentDisk(GcePersistentDisk gcePersistentDisk)

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

withNewGcePersistentDisk

public VolumesFluent.GcePersistentDiskNested<A> withNewGcePersistentDisk()

withNewGcePersistentDiskLike

public VolumesFluent.GcePersistentDiskNested<A> withNewGcePersistentDiskLike(GcePersistentDisk item)

editGcePersistentDisk

public VolumesFluent.GcePersistentDiskNested<A> editGcePersistentDisk()

editOrNewGcePersistentDisk

public VolumesFluent.GcePersistentDiskNested<A> editOrNewGcePersistentDisk()

editOrNewGcePersistentDiskLike

public VolumesFluent.GcePersistentDiskNested<A> editOrNewGcePersistentDiskLike(GcePersistentDisk item)

buildGitRepo
```
public GitRepo buildGitRepo()
```

withGitRepo

public A withGitRepo(GitRepo gitRepo)

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

withNewGitRepo

public VolumesFluent.GitRepoNested<A> withNewGitRepo()

withNewGitRepoLike

public VolumesFluent.GitRepoNested<A> withNewGitRepoLike(GitRepo item)

editGitRepo

public VolumesFluent.GitRepoNested<A> editGitRepo()

editOrNewGitRepo

public VolumesFluent.GitRepoNested<A> editOrNewGitRepo()

editOrNewGitRepoLike

public VolumesFluent.GitRepoNested<A> editOrNewGitRepoLike(GitRepo item)

buildGlusterfs
```
public Glusterfs buildGlusterfs()
```

withGlusterfs

public A withGlusterfs(Glusterfs glusterfs)

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

withNewGlusterfs

public VolumesFluent.GlusterfsNested<A> withNewGlusterfs()

withNewGlusterfsLike

public VolumesFluent.GlusterfsNested<A> withNewGlusterfsLike(Glusterfs item)

editGlusterfs

public VolumesFluent.GlusterfsNested<A> editGlusterfs()

editOrNewGlusterfs

public VolumesFluent.GlusterfsNested<A> editOrNewGlusterfs()

editOrNewGlusterfsLike

public VolumesFluent.GlusterfsNested<A> editOrNewGlusterfsLike(Glusterfs item)

buildHostPath
```
public HostPath buildHostPath()
```

withHostPath

public A withHostPath(HostPath hostPath)

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

withNewHostPath

public VolumesFluent.HostPathNested<A> withNewHostPath()

withNewHostPathLike

public VolumesFluent.HostPathNested<A> withNewHostPathLike(HostPath item)

editHostPath

public VolumesFluent.HostPathNested<A> editHostPath()

editOrNewHostPath

public VolumesFluent.HostPathNested<A> editOrNewHostPath()

editOrNewHostPathLike

public VolumesFluent.HostPathNested<A> editOrNewHostPathLike(HostPath item)

buildIscsi
```
public Iscsi buildIscsi()
```

withIscsi
```
public A withIscsi(Iscsi iscsi)
```

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

withNewIscsi

public VolumesFluent.IscsiNested<A> withNewIscsi()

withNewIscsiLike

public VolumesFluent.IscsiNested<A> withNewIscsiLike(Iscsi item)

editIscsi

public VolumesFluent.IscsiNested<A> editIscsi()

editOrNewIscsi

public VolumesFluent.IscsiNested<A> editOrNewIscsi()

editOrNewIscsiLike

public VolumesFluent.IscsiNested<A> editOrNewIscsiLike(Iscsi item)

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

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

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

buildNfs
```
public Nfs buildNfs()
```

withNfs
```
public A withNfs(Nfs nfs)
```

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

withNewNfs

public VolumesFluent.NfsNested<A> withNewNfs()

withNewNfsLike

public VolumesFluent.NfsNested<A> withNewNfsLike(Nfs item)

editNfs

public VolumesFluent.NfsNested<A> editNfs()

editOrNewNfs

public VolumesFluent.NfsNested<A> editOrNewNfs()

editOrNewNfsLike

public VolumesFluent.NfsNested<A> editOrNewNfsLike(Nfs item)

buildPersistentVolumeClaim

public PersistentVolumeClaim buildPersistentVolumeClaim()

withPersistentVolumeClaim

public A withPersistentVolumeClaim(PersistentVolumeClaim persistentVolumeClaim)

hasPersistentVolumeClaim

public boolean hasPersistentVolumeClaim()

withNewPersistentVolumeClaim

public VolumesFluent.PersistentVolumeClaimNested<A> withNewPersistentVolumeClaim()

withNewPersistentVolumeClaimLike

public VolumesFluent.PersistentVolumeClaimNested<A> withNewPersistentVolumeClaimLike(PersistentVolumeClaim item)

editPersistentVolumeClaim

public VolumesFluent.PersistentVolumeClaimNested<A> editPersistentVolumeClaim()

editOrNewPersistentVolumeClaim

public VolumesFluent.PersistentVolumeClaimNested<A> editOrNewPersistentVolumeClaim()

editOrNewPersistentVolumeClaimLike

public VolumesFluent.PersistentVolumeClaimNested<A> editOrNewPersistentVolumeClaimLike(PersistentVolumeClaim item)

buildPhotonPersistentDisk

public PhotonPersistentDisk buildPhotonPersistentDisk()

withPhotonPersistentDisk

public A withPhotonPersistentDisk(PhotonPersistentDisk photonPersistentDisk)

hasPhotonPersistentDisk

public boolean hasPhotonPersistentDisk()

withNewPhotonPersistentDisk

public VolumesFluent.PhotonPersistentDiskNested<A> withNewPhotonPersistentDisk()

withNewPhotonPersistentDiskLike

public VolumesFluent.PhotonPersistentDiskNested<A> withNewPhotonPersistentDiskLike(PhotonPersistentDisk item)

editPhotonPersistentDisk

public VolumesFluent.PhotonPersistentDiskNested<A> editPhotonPersistentDisk()

editOrNewPhotonPersistentDisk

public VolumesFluent.PhotonPersistentDiskNested<A> editOrNewPhotonPersistentDisk()

editOrNewPhotonPersistentDiskLike

public VolumesFluent.PhotonPersistentDiskNested<A> editOrNewPhotonPersistentDiskLike(PhotonPersistentDisk item)

buildPortworxVolume

public PortworxVolume buildPortworxVolume()

withPortworxVolume

public A withPortworxVolume(PortworxVolume portworxVolume)

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

withNewPortworxVolume

public VolumesFluent.PortworxVolumeNested<A> withNewPortworxVolume()

withNewPortworxVolumeLike

public VolumesFluent.PortworxVolumeNested<A> withNewPortworxVolumeLike(PortworxVolume item)

editPortworxVolume

public VolumesFluent.PortworxVolumeNested<A> editPortworxVolume()

editOrNewPortworxVolume

public VolumesFluent.PortworxVolumeNested<A> editOrNewPortworxVolume()

editOrNewPortworxVolumeLike

public VolumesFluent.PortworxVolumeNested<A> editOrNewPortworxVolumeLike(PortworxVolume item)

buildProjected
```
public Projected buildProjected()
```

withProjected

public A withProjected(Projected projected)

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

withNewProjected

public VolumesFluent.ProjectedNested<A> withNewProjected()

withNewProjectedLike

public VolumesFluent.ProjectedNested<A> withNewProjectedLike(Projected item)

editProjected

public VolumesFluent.ProjectedNested<A> editProjected()

editOrNewProjected

public VolumesFluent.ProjectedNested<A> editOrNewProjected()

editOrNewProjectedLike

public VolumesFluent.ProjectedNested<A> editOrNewProjectedLike(Projected item)

buildQuobyte
```
public Quobyte buildQuobyte()
```

withQuobyte

public A withQuobyte(Quobyte quobyte)

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

withNewQuobyte

public VolumesFluent.QuobyteNested<A> withNewQuobyte()

withNewQuobyteLike

public VolumesFluent.QuobyteNested<A> withNewQuobyteLike(Quobyte item)

editQuobyte

public VolumesFluent.QuobyteNested<A> editQuobyte()

editOrNewQuobyte

public VolumesFluent.QuobyteNested<A> editOrNewQuobyte()

editOrNewQuobyteLike

public VolumesFluent.QuobyteNested<A> editOrNewQuobyteLike(Quobyte item)

buildRbd
```
public Rbd buildRbd()
```

withRbd
```
public A withRbd(Rbd rbd)
```

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

withNewRbd

public VolumesFluent.RbdNested<A> withNewRbd()

withNewRbdLike

public VolumesFluent.RbdNested<A> withNewRbdLike(Rbd item)

editRbd

public VolumesFluent.RbdNested<A> editRbd()

editOrNewRbd

public VolumesFluent.RbdNested<A> editOrNewRbd()

editOrNewRbdLike

public VolumesFluent.RbdNested<A> editOrNewRbdLike(Rbd item)

buildScaleIO
```
public ScaleIO buildScaleIO()
```

withScaleIO

public A withScaleIO(ScaleIO scaleIO)

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

withNewScaleIO

public VolumesFluent.ScaleIONested<A> withNewScaleIO()

withNewScaleIOLike

public VolumesFluent.ScaleIONested<A> withNewScaleIOLike(ScaleIO item)

editScaleIO

public VolumesFluent.ScaleIONested<A> editScaleIO()

editOrNewScaleIO

public VolumesFluent.ScaleIONested<A> editOrNewScaleIO()

editOrNewScaleIOLike

public VolumesFluent.ScaleIONested<A> editOrNewScaleIOLike(ScaleIO item)

buildSecret
```
public Secret buildSecret()
```

withSecret

public A withSecret(Secret secret)

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

withNewSecret

public VolumesFluent.SecretNested<A> withNewSecret()

withNewSecretLike

public VolumesFluent.SecretNested<A> withNewSecretLike(Secret item)

editSecret

public VolumesFluent.SecretNested<A> editSecret()

editOrNewSecret

public VolumesFluent.SecretNested<A> editOrNewSecret()

editOrNewSecretLike

public VolumesFluent.SecretNested<A> editOrNewSecretLike(Secret item)

buildStorageos
```
public Storageos buildStorageos()
```

withStorageos

public A withStorageos(Storageos storageos)

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

withNewStorageos

public VolumesFluent.StorageosNested<A> withNewStorageos()

withNewStorageosLike

public VolumesFluent.StorageosNested<A> withNewStorageosLike(Storageos item)

editStorageos

public VolumesFluent.StorageosNested<A> editStorageos()

editOrNewStorageos

public VolumesFluent.StorageosNested<A> editOrNewStorageos()

editOrNewStorageosLike

public VolumesFluent.StorageosNested<A> editOrNewStorageosLike(Storageos item)

buildVsphereVolume

public VsphereVolume buildVsphereVolume()

withVsphereVolume

public A withVsphereVolume(VsphereVolume vsphereVolume)

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

withNewVsphereVolume

public VolumesFluent.VsphereVolumeNested<A> withNewVsphereVolume()

withNewVsphereVolumeLike

public VolumesFluent.VsphereVolumeNested<A> withNewVsphereVolumeLike(VsphereVolume item)

editVsphereVolume

public VolumesFluent.VsphereVolumeNested<A> editVsphereVolume()

editOrNewVsphereVolume

public VolumesFluent.VsphereVolumeNested<A> editOrNewVsphereVolume()

editOrNewVsphereVolumeLike

public VolumesFluent.VsphereVolumeNested<A> editOrNewVsphereVolumeLike(VsphereVolume item)

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

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

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

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

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

toString in class Object

Constructors
Constructor	Description
`VolumesFluent()`
`VolumesFluent(Volumes instance)`

Class VolumesFluent<A extends VolumesFluent<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

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable

Constructor Detail

VolumesFluent

VolumesFluent

Method Detail

buildAwsElasticBlockStore

withAwsElasticBlockStore

hasAwsElasticBlockStore

withNewAwsElasticBlockStore

withNewAwsElasticBlockStoreLike

editAwsElasticBlockStore

editOrNewAwsElasticBlockStore

editOrNewAwsElasticBlockStoreLike

buildAzureDisk

withAzureDisk

hasAzureDisk

withNewAzureDisk

withNewAzureDiskLike

editAzureDisk

editOrNewAzureDisk

editOrNewAzureDiskLike

buildAzureFile

withAzureFile

hasAzureFile

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

withEmptyDir

hasEmptyDir