• Home
• org.domeos
• kubernetes-model
• 1.1.0
• source code
• VolumeFluentImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.fabric8.kubernetes.api.model.VolumeFluentImpl Maven / Gradle / Ivy

package io.fabric8.kubernetes.api.model;

import io.fabric8.kubernetes.api.builder.BaseFluent;
import io.fabric8.kubernetes.api.builder.VisitableBuilder;
import com.fasterxml.jackson.annotation.JsonProperty;
import javax.validation.Valid;
import java.lang.String;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.lang.Integer;
import java.lang.Boolean;
import java.lang.Object;
import io.fabric8.kubernetes.api.builder.Nested;

public class VolumeFluentImpl> extends BaseFluent implements VolumeFluent{

    private VisitableBuilder awsElasticBlockStore;
    private VisitableBuilder azureFile;
    private VisitableBuilder cephfs;
    private VisitableBuilder cinder;
    private VisitableBuilder configMap;
    private VisitableBuilder downwardAPI;
    private VisitableBuilder emptyDir;
    private VisitableBuilder fc;
    private VisitableBuilder flexVolume;
    private VisitableBuilder flocker;
    private VisitableBuilder gcePersistentDisk;
    private VisitableBuilder gitRepo;
    private VisitableBuilder glusterfs;
    private VisitableBuilder hostPath;
    private VisitableBuilder iscsi;
    private VisitableBuilder metadata;
    private String name;
    private VisitableBuilder nfs;
    private VisitableBuilder persistentVolumeClaim;
    private VisitableBuilder rbd;
    private VisitableBuilder secret;
    private VisitableBuilder vsphereVolume;

    public VolumeFluentImpl(){
    }
    public VolumeFluentImpl(Volume instance){
            this.withAwsElasticBlockStore(instance.getAwsElasticBlockStore()); 
            this.withAzureFile(instance.getAzureFile()); 
            this.withCephfs(instance.getCephfs()); 
            this.withCinder(instance.getCinder()); 
            this.withConfigMap(instance.getConfigMap()); 
            this.withDownwardAPI(instance.getDownwardAPI()); 
            this.withEmptyDir(instance.getEmptyDir()); 
            this.withFc(instance.getFc()); 
            this.withFlexVolume(instance.getFlexVolume()); 
            this.withFlocker(instance.getFlocker()); 
            this.withGcePersistentDisk(instance.getGcePersistentDisk()); 
            this.withGitRepo(instance.getGitRepo()); 
            this.withGlusterfs(instance.getGlusterfs()); 
            this.withHostPath(instance.getHostPath()); 
            this.withIscsi(instance.getIscsi()); 
            this.withMetadata(instance.getMetadata()); 
            this.withName(instance.getName()); 
            this.withNfs(instance.getNfs()); 
            this.withPersistentVolumeClaim(instance.getPersistentVolumeClaim()); 
            this.withRbd(instance.getRbd()); 
            this.withSecret(instance.getSecret()); 
            this.withVsphereVolume(instance.getVsphereVolume()); 
    }

    public AWSElasticBlockStoreVolumeSource getAwsElasticBlockStore(){
            return this.awsElasticBlockStore!=null?this.awsElasticBlockStore.build():null;
    }

    public A withAwsElasticBlockStore(AWSElasticBlockStoreVolumeSource awsElasticBlockStore){
            if (awsElasticBlockStore!=null){ this.awsElasticBlockStore= new AWSElasticBlockStoreVolumeSourceBuilder(awsElasticBlockStore); _visitables.add(this.awsElasticBlockStore);} return (A) this;
    }

    public VolumeFluent.AwsElasticBlockStoreNested withNewAwsElasticBlockStore(){
            return new AwsElasticBlockStoreNestedImpl();
    }

    public VolumeFluent.AwsElasticBlockStoreNested withNewAwsElasticBlockStoreLike(AWSElasticBlockStoreVolumeSource item){
            return new AwsElasticBlockStoreNestedImpl(item);
    }

    public VolumeFluent.AwsElasticBlockStoreNested editAwsElasticBlockStore(){
            return withNewAwsElasticBlockStoreLike(getAwsElasticBlockStore());
    }

    public A withNewAwsElasticBlockStore(String fsType,Integer partition,Boolean readOnly,String volumeID){
            return (A)withAwsElasticBlockStore(new AWSElasticBlockStoreVolumeSource(fsType, partition, readOnly, volumeID));
    }

    public AzureFileVolumeSource getAzureFile(){
            return this.azureFile!=null?this.azureFile.build():null;
    }

    public A withAzureFile(AzureFileVolumeSource azureFile){
            if (azureFile!=null){ this.azureFile= new AzureFileVolumeSourceBuilder(azureFile); _visitables.add(this.azureFile);} return (A) this;
    }

    public VolumeFluent.AzureFileNested withNewAzureFile(){
            return new AzureFileNestedImpl();
    }

    public VolumeFluent.AzureFileNested withNewAzureFileLike(AzureFileVolumeSource item){
            return new AzureFileNestedImpl(item);
    }

    public VolumeFluent.AzureFileNested editAzureFile(){
            return withNewAzureFileLike(getAzureFile());
    }

    public A withNewAzureFile(Boolean readOnly,String secretName,String shareName){
            return (A)withAzureFile(new AzureFileVolumeSource(readOnly, secretName, shareName));
    }

    public CephFSVolumeSource getCephfs(){
            return this.cephfs!=null?this.cephfs.build():null;
    }

    public A withCephfs(CephFSVolumeSource cephfs){
            if (cephfs!=null){ this.cephfs= new CephFSVolumeSourceBuilder(cephfs); _visitables.add(this.cephfs);} return (A) this;
    }

    public VolumeFluent.CephfsNested withNewCephfs(){
            return new CephfsNestedImpl();
    }

    public VolumeFluent.CephfsNested withNewCephfsLike(CephFSVolumeSource item){
            return new CephfsNestedImpl(item);
    }

    public VolumeFluent.CephfsNested editCephfs(){
            return withNewCephfsLike(getCephfs());
    }

    public CinderVolumeSource getCinder(){
            return this.cinder!=null?this.cinder.build():null;
    }

    public A withCinder(CinderVolumeSource cinder){
            if (cinder!=null){ this.cinder= new CinderVolumeSourceBuilder(cinder); _visitables.add(this.cinder);} return (A) this;
    }

    public VolumeFluent.CinderNested withNewCinder(){
            return new CinderNestedImpl();
    }

    public VolumeFluent.CinderNested withNewCinderLike(CinderVolumeSource item){
            return new CinderNestedImpl(item);
    }

    public VolumeFluent.CinderNested editCinder(){
            return withNewCinderLike(getCinder());
    }

    public A withNewCinder(String fsType,Boolean readOnly,String volumeID){
            return (A)withCinder(new CinderVolumeSource(fsType, readOnly, volumeID));
    }

    public ConfigMapVolumeSource getConfigMap(){
            return this.configMap!=null?this.configMap.build():null;
    }

    public A withConfigMap(ConfigMapVolumeSource configMap){
            if (configMap!=null){ this.configMap= new ConfigMapVolumeSourceBuilder(configMap); _visitables.add(this.configMap);} return (A) this;
    }

    public VolumeFluent.ConfigMapNested withNewConfigMap(){
            return new ConfigMapNestedImpl();
    }

    public VolumeFluent.ConfigMapNested withNewConfigMapLike(ConfigMapVolumeSource item){
            return new ConfigMapNestedImpl(item);
    }

    public VolumeFluent.ConfigMapNested editConfigMap(){
            return withNewConfigMapLike(getConfigMap());
    }

    public DownwardAPIVolumeSource getDownwardAPI(){
            return this.downwardAPI!=null?this.downwardAPI.build():null;
    }

    public A withDownwardAPI(DownwardAPIVolumeSource downwardAPI){
            if (downwardAPI!=null){ this.downwardAPI= new DownwardAPIVolumeSourceBuilder(downwardAPI); _visitables.add(this.downwardAPI);} return (A) this;
    }

    public VolumeFluent.DownwardAPINested withNewDownwardAPI(){
            return new DownwardAPINestedImpl();
    }

    public VolumeFluent.DownwardAPINested withNewDownwardAPILike(DownwardAPIVolumeSource item){
            return new DownwardAPINestedImpl(item);
    }

    public VolumeFluent.DownwardAPINested editDownwardAPI(){
            return withNewDownwardAPILike(getDownwardAPI());
    }

    public EmptyDirVolumeSource getEmptyDir(){
            return this.emptyDir!=null?this.emptyDir.build():null;
    }

    public A withEmptyDir(EmptyDirVolumeSource emptyDir){
            if (emptyDir!=null){ this.emptyDir= new EmptyDirVolumeSourceBuilder(emptyDir); _visitables.add(this.emptyDir);} return (A) this;
    }

    public VolumeFluent.EmptyDirNested withNewEmptyDir(){
            return new EmptyDirNestedImpl();
    }

    public VolumeFluent.EmptyDirNested withNewEmptyDirLike(EmptyDirVolumeSource item){
            return new EmptyDirNestedImpl(item);
    }

    public VolumeFluent.EmptyDirNested editEmptyDir(){
            return withNewEmptyDirLike(getEmptyDir());
    }

    public A withNewEmptyDir(String medium){
            return (A)withEmptyDir(new EmptyDirVolumeSource(medium));
    }

    public FCVolumeSource getFc(){
            return this.fc!=null?this.fc.build():null;
    }

    public A withFc(FCVolumeSource fc){
            if (fc!=null){ this.fc= new FCVolumeSourceBuilder(fc); _visitables.add(this.fc);} return (A) this;
    }

    public VolumeFluent.FcNested withNewFc(){
            return new FcNestedImpl();
    }

    public VolumeFluent.FcNested withNewFcLike(FCVolumeSource item){
            return new FcNestedImpl(item);
    }

    public VolumeFluent.FcNested editFc(){
            return withNewFcLike(getFc());
    }

    public FlexVolumeSource getFlexVolume(){
            return this.flexVolume!=null?this.flexVolume.build():null;
    }

    public A withFlexVolume(FlexVolumeSource flexVolume){
            if (flexVolume!=null){ this.flexVolume= new FlexVolumeSourceBuilder(flexVolume); _visitables.add(this.flexVolume);} return (A) this;
    }

    public VolumeFluent.FlexVolumeNested withNewFlexVolume(){
            return new FlexVolumeNestedImpl();
    }

    public VolumeFluent.FlexVolumeNested withNewFlexVolumeLike(FlexVolumeSource item){
            return new FlexVolumeNestedImpl(item);
    }

    public VolumeFluent.FlexVolumeNested editFlexVolume(){
            return withNewFlexVolumeLike(getFlexVolume());
    }

    public FlockerVolumeSource getFlocker(){
            return this.flocker!=null?this.flocker.build():null;
    }

    public A withFlocker(FlockerVolumeSource flocker){
            if (flocker!=null){ this.flocker= new FlockerVolumeSourceBuilder(flocker); _visitables.add(this.flocker);} return (A) this;
    }

    public VolumeFluent.FlockerNested withNewFlocker(){
            return new FlockerNestedImpl();
    }

    public VolumeFluent.FlockerNested withNewFlockerLike(FlockerVolumeSource item){
            return new FlockerNestedImpl(item);
    }

    public VolumeFluent.FlockerNested editFlocker(){
            return withNewFlockerLike(getFlocker());
    }

    public A withNewFlocker(String datasetName){
            return (A)withFlocker(new FlockerVolumeSource(datasetName));
    }

    public GCEPersistentDiskVolumeSource getGcePersistentDisk(){
            return this.gcePersistentDisk!=null?this.gcePersistentDisk.build():null;
    }

    public A withGcePersistentDisk(GCEPersistentDiskVolumeSource gcePersistentDisk){
            if (gcePersistentDisk!=null){ this.gcePersistentDisk= new GCEPersistentDiskVolumeSourceBuilder(gcePersistentDisk); _visitables.add(this.gcePersistentDisk);} return (A) this;
    }

    public VolumeFluent.GcePersistentDiskNested withNewGcePersistentDisk(){
            return new GcePersistentDiskNestedImpl();
    }

    public VolumeFluent.GcePersistentDiskNested withNewGcePersistentDiskLike(GCEPersistentDiskVolumeSource item){
            return new GcePersistentDiskNestedImpl(item);
    }

    public VolumeFluent.GcePersistentDiskNested editGcePersistentDisk(){
            return withNewGcePersistentDiskLike(getGcePersistentDisk());
    }

    public A withNewGcePersistentDisk(String fsType,Integer partition,String pdName,Boolean readOnly){
            return (A)withGcePersistentDisk(new GCEPersistentDiskVolumeSource(fsType, partition, pdName, readOnly));
    }

    public GitRepoVolumeSource getGitRepo(){
            return this.gitRepo!=null?this.gitRepo.build():null;
    }

    public A withGitRepo(GitRepoVolumeSource gitRepo){
            if (gitRepo!=null){ this.gitRepo= new GitRepoVolumeSourceBuilder(gitRepo); _visitables.add(this.gitRepo);} return (A) this;
    }

    public VolumeFluent.GitRepoNested withNewGitRepo(){
            return new GitRepoNestedImpl();
    }

    public VolumeFluent.GitRepoNested withNewGitRepoLike(GitRepoVolumeSource item){
            return new GitRepoNestedImpl(item);
    }

    public VolumeFluent.GitRepoNested editGitRepo(){
            return withNewGitRepoLike(getGitRepo());
    }

    public A withNewGitRepo(String directory,String repository,String revision){
            return (A)withGitRepo(new GitRepoVolumeSource(directory, repository, revision));
    }

    public GlusterfsVolumeSource getGlusterfs(){
            return this.glusterfs!=null?this.glusterfs.build():null;
    }

    public A withGlusterfs(GlusterfsVolumeSource glusterfs){
            if (glusterfs!=null){ this.glusterfs= new GlusterfsVolumeSourceBuilder(glusterfs); _visitables.add(this.glusterfs);} return (A) this;
    }

    public VolumeFluent.GlusterfsNested withNewGlusterfs(){
            return new GlusterfsNestedImpl();
    }

    public VolumeFluent.GlusterfsNested withNewGlusterfsLike(GlusterfsVolumeSource item){
            return new GlusterfsNestedImpl(item);
    }

    public VolumeFluent.GlusterfsNested editGlusterfs(){
            return withNewGlusterfsLike(getGlusterfs());
    }

    public A withNewGlusterfs(String endpoints,String path,Boolean readOnly){
            return (A)withGlusterfs(new GlusterfsVolumeSource(endpoints, path, readOnly));
    }

    public HostPathVolumeSource getHostPath(){
            return this.hostPath!=null?this.hostPath.build():null;
    }

    public A withHostPath(HostPathVolumeSource hostPath){
            if (hostPath!=null){ this.hostPath= new HostPathVolumeSourceBuilder(hostPath); _visitables.add(this.hostPath);} return (A) this;
    }

    public VolumeFluent.HostPathNested withNewHostPath(){
            return new HostPathNestedImpl();
    }

    public VolumeFluent.HostPathNested withNewHostPathLike(HostPathVolumeSource item){
            return new HostPathNestedImpl(item);
    }

    public VolumeFluent.HostPathNested editHostPath(){
            return withNewHostPathLike(getHostPath());
    }

    public A withNewHostPath(String path){
            return (A)withHostPath(new HostPathVolumeSource(path));
    }

    public ISCSIVolumeSource getIscsi(){
            return this.iscsi!=null?this.iscsi.build():null;
    }

    public A withIscsi(ISCSIVolumeSource iscsi){
            if (iscsi!=null){ this.iscsi= new ISCSIVolumeSourceBuilder(iscsi); _visitables.add(this.iscsi);} return (A) this;
    }

    public VolumeFluent.IscsiNested withNewIscsi(){
            return new IscsiNestedImpl();
    }

    public VolumeFluent.IscsiNested withNewIscsiLike(ISCSIVolumeSource item){
            return new IscsiNestedImpl(item);
    }

    public VolumeFluent.IscsiNested editIscsi(){
            return withNewIscsiLike(getIscsi());
    }

    public DeprecatedDownwardAPIVolumeSource getMetadata(){
            return this.metadata!=null?this.metadata.build():null;
    }

    public A withMetadata(DeprecatedDownwardAPIVolumeSource metadata){
            if (metadata!=null){ this.metadata= new DeprecatedDownwardAPIVolumeSourceBuilder(metadata); _visitables.add(this.metadata);} return (A) this;
    }

    public VolumeFluent.MetadataNested withNewMetadata(){
            return new MetadataNestedImpl();
    }

    public VolumeFluent.MetadataNested withNewMetadataLike(DeprecatedDownwardAPIVolumeSource item){
            return new MetadataNestedImpl(item);
    }

    public VolumeFluent.MetadataNested editMetadata(){
            return withNewMetadataLike(getMetadata());
    }

    public String getName(){
            return this.name;
    }

    public A withName(String name){
            this.name=name; return (A) this;
    }

    public NFSVolumeSource getNfs(){
            return this.nfs!=null?this.nfs.build():null;
    }

    public A withNfs(NFSVolumeSource nfs){
            if (nfs!=null){ this.nfs= new NFSVolumeSourceBuilder(nfs); _visitables.add(this.nfs);} return (A) this;
    }

    public VolumeFluent.NfsNested withNewNfs(){
            return new NfsNestedImpl();
    }

    public VolumeFluent.NfsNested withNewNfsLike(NFSVolumeSource item){
            return new NfsNestedImpl(item);
    }

    public VolumeFluent.NfsNested editNfs(){
            return withNewNfsLike(getNfs());
    }

    public A withNewNfs(String path,Boolean readOnly,String server){
            return (A)withNfs(new NFSVolumeSource(path, readOnly, server));
    }

    public PersistentVolumeClaimVolumeSource getPersistentVolumeClaim(){
            return this.persistentVolumeClaim!=null?this.persistentVolumeClaim.build():null;
    }

    public A withPersistentVolumeClaim(PersistentVolumeClaimVolumeSource persistentVolumeClaim){
            if (persistentVolumeClaim!=null){ this.persistentVolumeClaim= new PersistentVolumeClaimVolumeSourceBuilder(persistentVolumeClaim); _visitables.add(this.persistentVolumeClaim);} return (A) this;
    }

    public VolumeFluent.PersistentVolumeClaimNested withNewPersistentVolumeClaim(){
            return new PersistentVolumeClaimNestedImpl();
    }

    public VolumeFluent.PersistentVolumeClaimNested withNewPersistentVolumeClaimLike(PersistentVolumeClaimVolumeSource item){
            return new PersistentVolumeClaimNestedImpl(item);
    }

    public VolumeFluent.PersistentVolumeClaimNested editPersistentVolumeClaim(){
            return withNewPersistentVolumeClaimLike(getPersistentVolumeClaim());
    }

    public A withNewPersistentVolumeClaim(String claimName,Boolean readOnly){
            return (A)withPersistentVolumeClaim(new PersistentVolumeClaimVolumeSource(claimName, readOnly));
    }

    public RBDVolumeSource getRbd(){
            return this.rbd!=null?this.rbd.build():null;
    }

    public A withRbd(RBDVolumeSource rbd){
            if (rbd!=null){ this.rbd= new RBDVolumeSourceBuilder(rbd); _visitables.add(this.rbd);} return (A) this;
    }

    public VolumeFluent.RbdNested withNewRbd(){
            return new RbdNestedImpl();
    }

    public VolumeFluent.RbdNested withNewRbdLike(RBDVolumeSource item){
            return new RbdNestedImpl(item);
    }

    public VolumeFluent.RbdNested editRbd(){
            return withNewRbdLike(getRbd());
    }

    public SecretVolumeSource getSecret(){
            return this.secret!=null?this.secret.build():null;
    }

    public A withSecret(SecretVolumeSource secret){
            if (secret!=null){ this.secret= new SecretVolumeSourceBuilder(secret); _visitables.add(this.secret);} return (A) this;
    }

    public VolumeFluent.SecretNested withNewSecret(){
            return new SecretNestedImpl();
    }

    public VolumeFluent.SecretNested withNewSecretLike(SecretVolumeSource item){
            return new SecretNestedImpl(item);
    }

    public VolumeFluent.SecretNested editSecret(){
            return withNewSecretLike(getSecret());
    }

    public VsphereVirtualDiskVolumeSource getVsphereVolume(){
            return this.vsphereVolume!=null?this.vsphereVolume.build():null;
    }

    public A withVsphereVolume(VsphereVirtualDiskVolumeSource vsphereVolume){
            if (vsphereVolume!=null){ this.vsphereVolume= new VsphereVirtualDiskVolumeSourceBuilder(vsphereVolume); _visitables.add(this.vsphereVolume);} return (A) this;
    }

    public VolumeFluent.VsphereVolumeNested withNewVsphereVolume(){
            return new VsphereVolumeNestedImpl();
    }

    public VolumeFluent.VsphereVolumeNested withNewVsphereVolumeLike(VsphereVirtualDiskVolumeSource item){
            return new VsphereVolumeNestedImpl(item);
    }

    public VolumeFluent.VsphereVolumeNested editVsphereVolume(){
            return withNewVsphereVolumeLike(getVsphereVolume());
    }

    public A withNewVsphereVolume(String fsType,String volumePath){
            return (A)withVsphereVolume(new VsphereVirtualDiskVolumeSource(fsType, volumePath));
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            VolumeFluentImpl that = (VolumeFluentImpl) o;
            if (awsElasticBlockStore != null ? !awsElasticBlockStore.equals(that.awsElasticBlockStore) :that.awsElasticBlockStore != null) return false;
            if (azureFile != null ? !azureFile.equals(that.azureFile) :that.azureFile != null) return false;
            if (cephfs != null ? !cephfs.equals(that.cephfs) :that.cephfs != null) return false;
            if (cinder != null ? !cinder.equals(that.cinder) :that.cinder != null) return false;
            if (configMap != null ? !configMap.equals(that.configMap) :that.configMap != null) return false;
            if (downwardAPI != null ? !downwardAPI.equals(that.downwardAPI) :that.downwardAPI != null) return false;
            if (emptyDir != null ? !emptyDir.equals(that.emptyDir) :that.emptyDir != null) return false;
            if (fc != null ? !fc.equals(that.fc) :that.fc != null) return false;
            if (flexVolume != null ? !flexVolume.equals(that.flexVolume) :that.flexVolume != null) return false;
            if (flocker != null ? !flocker.equals(that.flocker) :that.flocker != null) return false;
            if (gcePersistentDisk != null ? !gcePersistentDisk.equals(that.gcePersistentDisk) :that.gcePersistentDisk != null) return false;
            if (gitRepo != null ? !gitRepo.equals(that.gitRepo) :that.gitRepo != null) return false;
            if (glusterfs != null ? !glusterfs.equals(that.glusterfs) :that.glusterfs != null) return false;
            if (hostPath != null ? !hostPath.equals(that.hostPath) :that.hostPath != null) return false;
            if (iscsi != null ? !iscsi.equals(that.iscsi) :that.iscsi != null) return false;
            if (metadata != null ? !metadata.equals(that.metadata) :that.metadata != null) return false;
            if (name != null ? !name.equals(that.name) :that.name != null) return false;
            if (nfs != null ? !nfs.equals(that.nfs) :that.nfs != null) return false;
            if (persistentVolumeClaim != null ? !persistentVolumeClaim.equals(that.persistentVolumeClaim) :that.persistentVolumeClaim != null) return false;
            if (rbd != null ? !rbd.equals(that.rbd) :that.rbd != null) return false;
            if (secret != null ? !secret.equals(that.secret) :that.secret != null) return false;
            if (vsphereVolume != null ? !vsphereVolume.equals(that.vsphereVolume) :that.vsphereVolume != null) return false;
            return true;
    }


    public class AwsElasticBlockStoreNestedImpl extends AWSElasticBlockStoreVolumeSourceFluentImpl> implements VolumeFluent.AwsElasticBlockStoreNested,Nested{

            private final AWSElasticBlockStoreVolumeSourceBuilder builder;
    
            AwsElasticBlockStoreNestedImpl(){
                    this.builder = new AWSElasticBlockStoreVolumeSourceBuilder(this);
            }
            AwsElasticBlockStoreNestedImpl(AWSElasticBlockStoreVolumeSource item){
                    this.builder = new AWSElasticBlockStoreVolumeSourceBuilder(this, item);
            }
    
    public N endAwsElasticBlockStore(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withAwsElasticBlockStore(builder.build());
    }

}
    public class AzureFileNestedImpl extends AzureFileVolumeSourceFluentImpl> implements VolumeFluent.AzureFileNested,Nested{

            private final AzureFileVolumeSourceBuilder builder;
    
            AzureFileNestedImpl(){
                    this.builder = new AzureFileVolumeSourceBuilder(this);
            }
            AzureFileNestedImpl(AzureFileVolumeSource item){
                    this.builder = new AzureFileVolumeSourceBuilder(this, item);
            }
    
    public N endAzureFile(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withAzureFile(builder.build());
    }

}
    public class CephfsNestedImpl extends CephFSVolumeSourceFluentImpl> implements VolumeFluent.CephfsNested,Nested{

            private final CephFSVolumeSourceBuilder builder;
    
            CephfsNestedImpl(){
                    this.builder = new CephFSVolumeSourceBuilder(this);
            }
            CephfsNestedImpl(CephFSVolumeSource item){
                    this.builder = new CephFSVolumeSourceBuilder(this, item);
            }
    
    public N endCephfs(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withCephfs(builder.build());
    }

}
    public class CinderNestedImpl extends CinderVolumeSourceFluentImpl> implements VolumeFluent.CinderNested,Nested{

            private final CinderVolumeSourceBuilder builder;
    
            CinderNestedImpl(){
                    this.builder = new CinderVolumeSourceBuilder(this);
            }
            CinderNestedImpl(CinderVolumeSource item){
                    this.builder = new CinderVolumeSourceBuilder(this, item);
            }
    
    public N endCinder(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withCinder(builder.build());
    }

}
    public class ConfigMapNestedImpl extends ConfigMapVolumeSourceFluentImpl> implements VolumeFluent.ConfigMapNested,Nested{

            private final ConfigMapVolumeSourceBuilder builder;
    
            ConfigMapNestedImpl(){
                    this.builder = new ConfigMapVolumeSourceBuilder(this);
            }
            ConfigMapNestedImpl(ConfigMapVolumeSource item){
                    this.builder = new ConfigMapVolumeSourceBuilder(this, item);
            }
    
    public N endConfigMap(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withConfigMap(builder.build());
    }

}
    public class DownwardAPINestedImpl extends DownwardAPIVolumeSourceFluentImpl> implements VolumeFluent.DownwardAPINested,Nested{

            private final DownwardAPIVolumeSourceBuilder builder;
    
            DownwardAPINestedImpl(){
                    this.builder = new DownwardAPIVolumeSourceBuilder(this);
            }
            DownwardAPINestedImpl(DownwardAPIVolumeSource item){
                    this.builder = new DownwardAPIVolumeSourceBuilder(this, item);
            }
    
    public N endDownwardAPI(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withDownwardAPI(builder.build());
    }

}
    public class EmptyDirNestedImpl extends EmptyDirVolumeSourceFluentImpl> implements VolumeFluent.EmptyDirNested,Nested{

            private final EmptyDirVolumeSourceBuilder builder;
    
            EmptyDirNestedImpl(){
                    this.builder = new EmptyDirVolumeSourceBuilder(this);
            }
            EmptyDirNestedImpl(EmptyDirVolumeSource item){
                    this.builder = new EmptyDirVolumeSourceBuilder(this, item);
            }
    
    public N endEmptyDir(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withEmptyDir(builder.build());
    }

}
    public class FcNestedImpl extends FCVolumeSourceFluentImpl> implements VolumeFluent.FcNested,Nested{

            private final FCVolumeSourceBuilder builder;
    
            FcNestedImpl(){
                    this.builder = new FCVolumeSourceBuilder(this);
            }
            FcNestedImpl(FCVolumeSource item){
                    this.builder = new FCVolumeSourceBuilder(this, item);
            }
    
    public N endFc(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withFc(builder.build());
    }

}
    public class FlexVolumeNestedImpl extends FlexVolumeSourceFluentImpl> implements VolumeFluent.FlexVolumeNested,Nested{

            private final FlexVolumeSourceBuilder builder;
    
            FlexVolumeNestedImpl(){
                    this.builder = new FlexVolumeSourceBuilder(this);
            }
            FlexVolumeNestedImpl(FlexVolumeSource item){
                    this.builder = new FlexVolumeSourceBuilder(this, item);
            }
    
    public N endFlexVolume(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withFlexVolume(builder.build());
    }

}
    public class FlockerNestedImpl extends FlockerVolumeSourceFluentImpl> implements VolumeFluent.FlockerNested,Nested{

            private final FlockerVolumeSourceBuilder builder;
    
            FlockerNestedImpl(){
                    this.builder = new FlockerVolumeSourceBuilder(this);
            }
            FlockerNestedImpl(FlockerVolumeSource item){
                    this.builder = new FlockerVolumeSourceBuilder(this, item);
            }
    
    public N endFlocker(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withFlocker(builder.build());
    }

}
    public class GcePersistentDiskNestedImpl extends GCEPersistentDiskVolumeSourceFluentImpl> implements VolumeFluent.GcePersistentDiskNested,Nested{

            private final GCEPersistentDiskVolumeSourceBuilder builder;
    
            GcePersistentDiskNestedImpl(GCEPersistentDiskVolumeSource item){
                    this.builder = new GCEPersistentDiskVolumeSourceBuilder(this, item);
            }
            GcePersistentDiskNestedImpl(){
                    this.builder = new GCEPersistentDiskVolumeSourceBuilder(this);
            }
    
    public N endGcePersistentDisk(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withGcePersistentDisk(builder.build());
    }

}
    public class GitRepoNestedImpl extends GitRepoVolumeSourceFluentImpl> implements VolumeFluent.GitRepoNested,Nested{

            private final GitRepoVolumeSourceBuilder builder;
    
            GitRepoNestedImpl(){
                    this.builder = new GitRepoVolumeSourceBuilder(this);
            }
            GitRepoNestedImpl(GitRepoVolumeSource item){
                    this.builder = new GitRepoVolumeSourceBuilder(this, item);
            }
    
    public N endGitRepo(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withGitRepo(builder.build());
    }

}
    public class GlusterfsNestedImpl extends GlusterfsVolumeSourceFluentImpl> implements VolumeFluent.GlusterfsNested,Nested{

            private final GlusterfsVolumeSourceBuilder builder;
    
            GlusterfsNestedImpl(){
                    this.builder = new GlusterfsVolumeSourceBuilder(this);
            }
            GlusterfsNestedImpl(GlusterfsVolumeSource item){
                    this.builder = new GlusterfsVolumeSourceBuilder(this, item);
            }
    
    public N endGlusterfs(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withGlusterfs(builder.build());
    }

}
    public class HostPathNestedImpl extends HostPathVolumeSourceFluentImpl> implements VolumeFluent.HostPathNested,Nested{

            private final HostPathVolumeSourceBuilder builder;
    
            HostPathNestedImpl(){
                    this.builder = new HostPathVolumeSourceBuilder(this);
            }
            HostPathNestedImpl(HostPathVolumeSource item){
                    this.builder = new HostPathVolumeSourceBuilder(this, item);
            }
    
    public N endHostPath(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withHostPath(builder.build());
    }

}
    public class IscsiNestedImpl extends ISCSIVolumeSourceFluentImpl> implements VolumeFluent.IscsiNested,Nested{

            private final ISCSIVolumeSourceBuilder builder;
    
            IscsiNestedImpl(ISCSIVolumeSource item){
                    this.builder = new ISCSIVolumeSourceBuilder(this, item);
            }
            IscsiNestedImpl(){
                    this.builder = new ISCSIVolumeSourceBuilder(this);
            }
    
    public N endIscsi(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withIscsi(builder.build());
    }

}
    public class MetadataNestedImpl extends DeprecatedDownwardAPIVolumeSourceFluentImpl> implements VolumeFluent.MetadataNested,Nested{

            private final DeprecatedDownwardAPIVolumeSourceBuilder builder;
    
            MetadataNestedImpl(){
                    this.builder = new DeprecatedDownwardAPIVolumeSourceBuilder(this);
            }
            MetadataNestedImpl(DeprecatedDownwardAPIVolumeSource item){
                    this.builder = new DeprecatedDownwardAPIVolumeSourceBuilder(this, item);
            }
    
    public N endMetadata(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withMetadata(builder.build());
    }

}
    public class NfsNestedImpl extends NFSVolumeSourceFluentImpl> implements VolumeFluent.NfsNested,Nested{

            private final NFSVolumeSourceBuilder builder;
    
            NfsNestedImpl(){
                    this.builder = new NFSVolumeSourceBuilder(this);
            }
            NfsNestedImpl(NFSVolumeSource item){
                    this.builder = new NFSVolumeSourceBuilder(this, item);
            }
    
    public N endNfs(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withNfs(builder.build());
    }

}
    public class PersistentVolumeClaimNestedImpl extends PersistentVolumeClaimVolumeSourceFluentImpl> implements VolumeFluent.PersistentVolumeClaimNested,Nested{

            private final PersistentVolumeClaimVolumeSourceBuilder builder;
    
            PersistentVolumeClaimNestedImpl(){
                    this.builder = new PersistentVolumeClaimVolumeSourceBuilder(this);
            }
            PersistentVolumeClaimNestedImpl(PersistentVolumeClaimVolumeSource item){
                    this.builder = new PersistentVolumeClaimVolumeSourceBuilder(this, item);
            }
    
    public N endPersistentVolumeClaim(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withPersistentVolumeClaim(builder.build());
    }

}
    public class RbdNestedImpl extends RBDVolumeSourceFluentImpl> implements VolumeFluent.RbdNested,Nested{

            private final RBDVolumeSourceBuilder builder;
    
            RbdNestedImpl(RBDVolumeSource item){
                    this.builder = new RBDVolumeSourceBuilder(this, item);
            }
            RbdNestedImpl(){
                    this.builder = new RBDVolumeSourceBuilder(this);
            }
    
    public N endRbd(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withRbd(builder.build());
    }

}
    public class SecretNestedImpl extends SecretVolumeSourceFluentImpl> implements VolumeFluent.SecretNested,Nested{

            private final SecretVolumeSourceBuilder builder;
    
            SecretNestedImpl(){
                    this.builder = new SecretVolumeSourceBuilder(this);
            }
            SecretNestedImpl(SecretVolumeSource item){
                    this.builder = new SecretVolumeSourceBuilder(this, item);
            }
    
    public N endSecret(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withSecret(builder.build());
    }

}
    public class VsphereVolumeNestedImpl extends VsphereVirtualDiskVolumeSourceFluentImpl> implements VolumeFluent.VsphereVolumeNested,Nested{

            private final VsphereVirtualDiskVolumeSourceBuilder builder;
    
            VsphereVolumeNestedImpl(){
                    this.builder = new VsphereVirtualDiskVolumeSourceBuilder(this);
            }
            VsphereVolumeNestedImpl(VsphereVirtualDiskVolumeSource item){
                    this.builder = new VsphereVirtualDiskVolumeSourceBuilder(this, item);
            }
    
    public N endVsphereVolume(){
            return and();
    }
    public N and(){
            return (N) VolumeFluentImpl.this.withVsphereVolume(builder.build());
    }

}


}