All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

package io.fabric8.kubernetes.api.model;

import io.fabric8.openshift.api.model.OAuthClient;
import java.util.Map;
import io.fabric8.openshift.api.model.template.TemplateList;
import io.fabric8.openshift.api.model.OAuthAuthorizeToken;
import io.fabric8.openshift.api.model.BuildList;
import io.fabric8.openshift.api.model.TagEvent;
import io.fabric8.openshift.api.model.BuildConfigList;
import io.fabric8.openshift.api.model.ImageStreamList;
import io.fabric8.openshift.api.model.ImageList;
import io.fabric8.kubernetes.api.model.resource.Quantity;
import io.fabric8.kubernetes.api.model.config.Config;
import io.fabric8.openshift.api.model.OAuthAccessTokenList;
import io.fabric8.openshift.api.model.template.Template;
import io.fabric8.openshift.api.model.OAuthAuthorizeTokenList;
import io.fabric8.openshift.api.model.RouteList;
import io.fabric8.kubernetes.api.watch.WatchEvent;
import java.util.HashMap;
import io.fabric8.openshift.api.model.OAuthClientAuthorizationList;
import io.fabric8.openshift.api.model.OAuthAccessToken;
import io.fabric8.openshift.api.model.OAuthClientList;
import io.fabric8.kubernetes.api.model.errors.StatusError;
import io.fabric8.openshift.api.model.OAuthClientAuthorization;
import io.fabric8.openshift.api.model.DeploymentConfigList;
import io.fabric8.openshift.api.model.ImageStreamListBuilder;
import io.fabric8.common.Fluent;
import io.fabric8.common.Visitable;
import io.fabric8.openshift.api.model.ImageStreamListFluent;
import io.fabric8.openshift.api.model.OAuthAuthorizeTokenListFluent;
import io.fabric8.openshift.api.model.BuildConfigListFluent;
import io.fabric8.openshift.api.model.template.TemplateBuilder;
import io.fabric8.kubernetes.api.model.resource.QuantityBuilder;
import io.fabric8.openshift.api.model.OAuthClientBuilder;
import io.fabric8.openshift.api.model.OAuthAccessTokenBuilder;
import io.fabric8.openshift.api.model.OAuthAccessTokenListFluent;
import io.fabric8.openshift.api.model.DeploymentConfigListBuilder;
import io.fabric8.openshift.api.model.OAuthAuthorizeTokenListBuilder;
import io.fabric8.openshift.api.model.OAuthClientListFluent;
import io.fabric8.openshift.api.model.OAuthClientAuthorizationBuilder;
import io.fabric8.openshift.api.model.RouteListFluent;
import io.fabric8.common.BaseFluent;
import io.fabric8.openshift.api.model.BuildListFluent;
import io.fabric8.openshift.api.model.BuildConfigListBuilder;
import io.fabric8.openshift.api.model.template.TemplateFluent;
import io.fabric8.openshift.api.model.OAuthAccessTokenFluent;
import io.fabric8.openshift.api.model.ImageListBuilder;
import io.fabric8.common.Nested;
import io.fabric8.openshift.api.model.OAuthAuthorizeTokenFluent;
import io.fabric8.openshift.api.model.BuildListBuilder;
import io.fabric8.kubernetes.api.model.resource.QuantityFluent;
import io.fabric8.openshift.api.model.OAuthAuthorizeTokenBuilder;
import io.fabric8.openshift.api.model.OAuthClientAuthorizationListFluent;
import io.fabric8.openshift.api.model.ImageListFluent;
import io.fabric8.openshift.api.model.TagEventBuilder;
import io.fabric8.openshift.api.model.OAuthClientListBuilder;
import io.fabric8.openshift.api.model.OAuthClientAuthorizationListBuilder;
import io.fabric8.openshift.api.model.DeploymentConfigListFluent;
import io.fabric8.common.VisitableBuilder;
import io.fabric8.openshift.api.model.OAuthClientFluent;
import io.fabric8.openshift.api.model.OAuthAccessTokenListBuilder;
import io.fabric8.openshift.api.model.OAuthClientAuthorizationFluent;
import io.fabric8.openshift.api.model.TagEventFluent;
import io.fabric8.openshift.api.model.RouteListBuilder;

public class KubeSchemaFluent> extends BaseFluent implements Fluent{

     VisitableBuilder BaseKubernetesList;     VisitableBuilder BuildConfigList;     VisitableBuilder BuildList;     Config Config;     VisitableBuilder ContainerStatus;     VisitableBuilder DeploymentConfigList;     VisitableBuilder Endpoints;     VisitableBuilder EndpointsList;     VisitableBuilder EnvVar;     VisitableBuilder ImageList;     VisitableBuilder ImageStreamList;     VisitableBuilder Namespace;     VisitableBuilder NamespaceList;     VisitableBuilder Node;     VisitableBuilder NodeList;     VisitableBuilder OAuthAccessToken;     VisitableBuilder OAuthAccessTokenList;     VisitableBuilder OAuthAuthorizeToken;     VisitableBuilder OAuthAuthorizeTokenList;     VisitableBuilder OAuthClient;     VisitableBuilder OAuthClientAuthorization;     VisitableBuilder OAuthClientAuthorizationList;     VisitableBuilder OAuthClientList;     VisitableBuilder ObjectMeta;     VisitableBuilder PodList;     VisitableBuilder Quantity;     VisitableBuilder ReplicationControllerList;     VisitableBuilder RouteList;     VisitableBuilder Secret;     VisitableBuilder SecretList;     VisitableBuilder ServiceAccount;     VisitableBuilder ServiceAccountList;     VisitableBuilder ServiceList;     StatusError StatusError;     VisitableBuilder TagEvent;     VisitableBuilder Template;     TemplateList TemplateList;     WatchEvent WatchEvent;     Map additionalProperties = new HashMap();

    public BaseKubernetesList getBaseKubernetesList(){
    return this.BaseKubernetesList!=null?this.BaseKubernetesList.build():null;
    }
    public T withBaseKubernetesList( BaseKubernetesList BaseKubernetesList){
    if (BaseKubernetesList!=null){ this.BaseKubernetesList= new BaseKubernetesListBuilder(BaseKubernetesList); _visitables.add(this.BaseKubernetesList);} return (T) this;
    }
    public BaseKubernetesListNested withNewBaseKubernetesList(){
    return new BaseKubernetesListNested();
    }
    public BaseKubernetesListNested withNewBaseKubernetesListLike( BaseKubernetesList item){
    return new BaseKubernetesListNested(item);
    }
    public BaseKubernetesListNested editBaseKubernetesList(){
    return withNewBaseKubernetesListLike(getBaseKubernetesList());
    }
    public BuildConfigList getBuildConfigList(){
    return this.BuildConfigList!=null?this.BuildConfigList.build():null;
    }
    public T withBuildConfigList( BuildConfigList BuildConfigList){
    if (BuildConfigList!=null){ this.BuildConfigList= new BuildConfigListBuilder(BuildConfigList); _visitables.add(this.BuildConfigList);} return (T) this;
    }
    public BuildConfigListNested withNewBuildConfigList(){
    return new BuildConfigListNested();
    }
    public BuildConfigListNested withNewBuildConfigListLike( BuildConfigList item){
    return new BuildConfigListNested(item);
    }
    public BuildConfigListNested editBuildConfigList(){
    return withNewBuildConfigListLike(getBuildConfigList());
    }
    public BuildList getBuildList(){
    return this.BuildList!=null?this.BuildList.build():null;
    }
    public T withBuildList( BuildList BuildList){
    if (BuildList!=null){ this.BuildList= new BuildListBuilder(BuildList); _visitables.add(this.BuildList);} return (T) this;
    }
    public BuildListNested withNewBuildList(){
    return new BuildListNested();
    }
    public BuildListNested withNewBuildListLike( BuildList item){
    return new BuildListNested(item);
    }
    public BuildListNested editBuildList(){
    return withNewBuildListLike(getBuildList());
    }
    public Config getConfig(){
    return this.Config;
    }
    public T withConfig( Config Config){
    this.Config=Config; return (T) this;
    }
    public ContainerStatus getContainerStatus(){
    return this.ContainerStatus!=null?this.ContainerStatus.build():null;
    }
    public T withContainerStatus( ContainerStatus ContainerStatus){
    if (ContainerStatus!=null){ this.ContainerStatus= new ContainerStatusBuilder(ContainerStatus); _visitables.add(this.ContainerStatus);} return (T) this;
    }
    public ContainerStatusNested withNewContainerStatus(){
    return new ContainerStatusNested();
    }
    public ContainerStatusNested withNewContainerStatusLike( ContainerStatus item){
    return new ContainerStatusNested(item);
    }
    public ContainerStatusNested editContainerStatus(){
    return withNewContainerStatusLike(getContainerStatus());
    }
    public DeploymentConfigList getDeploymentConfigList(){
    return this.DeploymentConfigList!=null?this.DeploymentConfigList.build():null;
    }
    public T withDeploymentConfigList( DeploymentConfigList DeploymentConfigList){
    if (DeploymentConfigList!=null){ this.DeploymentConfigList= new DeploymentConfigListBuilder(DeploymentConfigList); _visitables.add(this.DeploymentConfigList);} return (T) this;
    }
    public DeploymentConfigListNested withNewDeploymentConfigList(){
    return new DeploymentConfigListNested();
    }
    public DeploymentConfigListNested withNewDeploymentConfigListLike( DeploymentConfigList item){
    return new DeploymentConfigListNested(item);
    }
    public DeploymentConfigListNested editDeploymentConfigList(){
    return withNewDeploymentConfigListLike(getDeploymentConfigList());
    }
    public Endpoints getEndpoints(){
    return this.Endpoints!=null?this.Endpoints.build():null;
    }
    public T withEndpoints( Endpoints Endpoints){
    if (Endpoints!=null){ this.Endpoints= new EndpointsBuilder(Endpoints); _visitables.add(this.Endpoints);} return (T) this;
    }
    public EndpointsNested withNewEndpoints(){
    return new EndpointsNested();
    }
    public EndpointsNested withNewEndpointsLike( Endpoints item){
    return new EndpointsNested(item);
    }
    public EndpointsNested editEndpoints(){
    return withNewEndpointsLike(getEndpoints());
    }
    public EndpointsList getEndpointsList(){
    return this.EndpointsList!=null?this.EndpointsList.build():null;
    }
    public T withEndpointsList( EndpointsList EndpointsList){
    if (EndpointsList!=null){ this.EndpointsList= new EndpointsListBuilder(EndpointsList); _visitables.add(this.EndpointsList);} return (T) this;
    }
    public EndpointsListNested withNewEndpointsList(){
    return new EndpointsListNested();
    }
    public EndpointsListNested withNewEndpointsListLike( EndpointsList item){
    return new EndpointsListNested(item);
    }
    public EndpointsListNested editEndpointsList(){
    return withNewEndpointsListLike(getEndpointsList());
    }
    public EnvVar getEnvVar(){
    return this.EnvVar!=null?this.EnvVar.build():null;
    }
    public T withEnvVar( EnvVar EnvVar){
    if (EnvVar!=null){ this.EnvVar= new EnvVarBuilder(EnvVar); _visitables.add(this.EnvVar);} return (T) this;
    }
    public EnvVarNested withNewEnvVar(){
    return new EnvVarNested();
    }
    public EnvVarNested withNewEnvVarLike( EnvVar item){
    return new EnvVarNested(item);
    }
    public EnvVarNested editEnvVar(){
    return withNewEnvVarLike(getEnvVar());
    }
    public ImageList getImageList(){
    return this.ImageList!=null?this.ImageList.build():null;
    }
    public T withImageList( ImageList ImageList){
    if (ImageList!=null){ this.ImageList= new ImageListBuilder(ImageList); _visitables.add(this.ImageList);} return (T) this;
    }
    public ImageListNested withNewImageList(){
    return new ImageListNested();
    }
    public ImageListNested withNewImageListLike( ImageList item){
    return new ImageListNested(item);
    }
    public ImageListNested editImageList(){
    return withNewImageListLike(getImageList());
    }
    public ImageStreamList getImageStreamList(){
    return this.ImageStreamList!=null?this.ImageStreamList.build():null;
    }
    public T withImageStreamList( ImageStreamList ImageStreamList){
    if (ImageStreamList!=null){ this.ImageStreamList= new ImageStreamListBuilder(ImageStreamList); _visitables.add(this.ImageStreamList);} return (T) this;
    }
    public ImageStreamListNested withNewImageStreamList(){
    return new ImageStreamListNested();
    }
    public ImageStreamListNested withNewImageStreamListLike( ImageStreamList item){
    return new ImageStreamListNested(item);
    }
    public ImageStreamListNested editImageStreamList(){
    return withNewImageStreamListLike(getImageStreamList());
    }
    public Namespace getNamespace(){
    return this.Namespace!=null?this.Namespace.build():null;
    }
    public T withNamespace( Namespace Namespace){
    if (Namespace!=null){ this.Namespace= new NamespaceBuilder(Namespace); _visitables.add(this.Namespace);} return (T) this;
    }
    public NamespaceNested withNewNamespace(){
    return new NamespaceNested();
    }
    public NamespaceNested withNewNamespaceLike( Namespace item){
    return new NamespaceNested(item);
    }
    public NamespaceNested editNamespace(){
    return withNewNamespaceLike(getNamespace());
    }
    public NamespaceList getNamespaceList(){
    return this.NamespaceList!=null?this.NamespaceList.build():null;
    }
    public T withNamespaceList( NamespaceList NamespaceList){
    if (NamespaceList!=null){ this.NamespaceList= new NamespaceListBuilder(NamespaceList); _visitables.add(this.NamespaceList);} return (T) this;
    }
    public NamespaceListNested withNewNamespaceList(){
    return new NamespaceListNested();
    }
    public NamespaceListNested withNewNamespaceListLike( NamespaceList item){
    return new NamespaceListNested(item);
    }
    public NamespaceListNested editNamespaceList(){
    return withNewNamespaceListLike(getNamespaceList());
    }
    public Node getNode(){
    return this.Node!=null?this.Node.build():null;
    }
    public T withNode( Node Node){
    if (Node!=null){ this.Node= new NodeBuilder(Node); _visitables.add(this.Node);} return (T) this;
    }
    public NodeNested withNewNode(){
    return new NodeNested();
    }
    public NodeNested withNewNodeLike( Node item){
    return new NodeNested(item);
    }
    public NodeNested editNode(){
    return withNewNodeLike(getNode());
    }
    public NodeList getNodeList(){
    return this.NodeList!=null?this.NodeList.build():null;
    }
    public T withNodeList( NodeList NodeList){
    if (NodeList!=null){ this.NodeList= new NodeListBuilder(NodeList); _visitables.add(this.NodeList);} return (T) this;
    }
    public NodeListNested withNewNodeList(){
    return new NodeListNested();
    }
    public NodeListNested withNewNodeListLike( NodeList item){
    return new NodeListNested(item);
    }
    public NodeListNested editNodeList(){
    return withNewNodeListLike(getNodeList());
    }
    public OAuthAccessToken getOAuthAccessToken(){
    return this.OAuthAccessToken!=null?this.OAuthAccessToken.build():null;
    }
    public T withOAuthAccessToken( OAuthAccessToken OAuthAccessToken){
    if (OAuthAccessToken!=null){ this.OAuthAccessToken= new OAuthAccessTokenBuilder(OAuthAccessToken); _visitables.add(this.OAuthAccessToken);} return (T) this;
    }
    public OAuthAccessTokenNested withNewOAuthAccessToken(){
    return new OAuthAccessTokenNested();
    }
    public OAuthAccessTokenNested withNewOAuthAccessTokenLike( OAuthAccessToken item){
    return new OAuthAccessTokenNested(item);
    }
    public OAuthAccessTokenNested editOAuthAccessToken(){
    return withNewOAuthAccessTokenLike(getOAuthAccessToken());
    }
    public OAuthAccessTokenList getOAuthAccessTokenList(){
    return this.OAuthAccessTokenList!=null?this.OAuthAccessTokenList.build():null;
    }
    public T withOAuthAccessTokenList( OAuthAccessTokenList OAuthAccessTokenList){
    if (OAuthAccessTokenList!=null){ this.OAuthAccessTokenList= new OAuthAccessTokenListBuilder(OAuthAccessTokenList); _visitables.add(this.OAuthAccessTokenList);} return (T) this;
    }
    public OAuthAccessTokenListNested withNewOAuthAccessTokenList(){
    return new OAuthAccessTokenListNested();
    }
    public OAuthAccessTokenListNested withNewOAuthAccessTokenListLike( OAuthAccessTokenList item){
    return new OAuthAccessTokenListNested(item);
    }
    public OAuthAccessTokenListNested editOAuthAccessTokenList(){
    return withNewOAuthAccessTokenListLike(getOAuthAccessTokenList());
    }
    public OAuthAuthorizeToken getOAuthAuthorizeToken(){
    return this.OAuthAuthorizeToken!=null?this.OAuthAuthorizeToken.build():null;
    }
    public T withOAuthAuthorizeToken( OAuthAuthorizeToken OAuthAuthorizeToken){
    if (OAuthAuthorizeToken!=null){ this.OAuthAuthorizeToken= new OAuthAuthorizeTokenBuilder(OAuthAuthorizeToken); _visitables.add(this.OAuthAuthorizeToken);} return (T) this;
    }
    public OAuthAuthorizeTokenNested withNewOAuthAuthorizeToken(){
    return new OAuthAuthorizeTokenNested();
    }
    public OAuthAuthorizeTokenNested withNewOAuthAuthorizeTokenLike( OAuthAuthorizeToken item){
    return new OAuthAuthorizeTokenNested(item);
    }
    public OAuthAuthorizeTokenNested editOAuthAuthorizeToken(){
    return withNewOAuthAuthorizeTokenLike(getOAuthAuthorizeToken());
    }
    public OAuthAuthorizeTokenList getOAuthAuthorizeTokenList(){
    return this.OAuthAuthorizeTokenList!=null?this.OAuthAuthorizeTokenList.build():null;
    }
    public T withOAuthAuthorizeTokenList( OAuthAuthorizeTokenList OAuthAuthorizeTokenList){
    if (OAuthAuthorizeTokenList!=null){ this.OAuthAuthorizeTokenList= new OAuthAuthorizeTokenListBuilder(OAuthAuthorizeTokenList); _visitables.add(this.OAuthAuthorizeTokenList);} return (T) this;
    }
    public OAuthAuthorizeTokenListNested withNewOAuthAuthorizeTokenList(){
    return new OAuthAuthorizeTokenListNested();
    }
    public OAuthAuthorizeTokenListNested withNewOAuthAuthorizeTokenListLike( OAuthAuthorizeTokenList item){
    return new OAuthAuthorizeTokenListNested(item);
    }
    public OAuthAuthorizeTokenListNested editOAuthAuthorizeTokenList(){
    return withNewOAuthAuthorizeTokenListLike(getOAuthAuthorizeTokenList());
    }
    public OAuthClient getOAuthClient(){
    return this.OAuthClient!=null?this.OAuthClient.build():null;
    }
    public T withOAuthClient( OAuthClient OAuthClient){
    if (OAuthClient!=null){ this.OAuthClient= new OAuthClientBuilder(OAuthClient); _visitables.add(this.OAuthClient);} return (T) this;
    }
    public OAuthClientNested withNewOAuthClient(){
    return new OAuthClientNested();
    }
    public OAuthClientNested withNewOAuthClientLike( OAuthClient item){
    return new OAuthClientNested(item);
    }
    public OAuthClientNested editOAuthClient(){
    return withNewOAuthClientLike(getOAuthClient());
    }
    public OAuthClientAuthorization getOAuthClientAuthorization(){
    return this.OAuthClientAuthorization!=null?this.OAuthClientAuthorization.build():null;
    }
    public T withOAuthClientAuthorization( OAuthClientAuthorization OAuthClientAuthorization){
    if (OAuthClientAuthorization!=null){ this.OAuthClientAuthorization= new OAuthClientAuthorizationBuilder(OAuthClientAuthorization); _visitables.add(this.OAuthClientAuthorization);} return (T) this;
    }
    public OAuthClientAuthorizationNested withNewOAuthClientAuthorization(){
    return new OAuthClientAuthorizationNested();
    }
    public OAuthClientAuthorizationNested withNewOAuthClientAuthorizationLike( OAuthClientAuthorization item){
    return new OAuthClientAuthorizationNested(item);
    }
    public OAuthClientAuthorizationNested editOAuthClientAuthorization(){
    return withNewOAuthClientAuthorizationLike(getOAuthClientAuthorization());
    }
    public OAuthClientAuthorizationList getOAuthClientAuthorizationList(){
    return this.OAuthClientAuthorizationList!=null?this.OAuthClientAuthorizationList.build():null;
    }
    public T withOAuthClientAuthorizationList( OAuthClientAuthorizationList OAuthClientAuthorizationList){
    if (OAuthClientAuthorizationList!=null){ this.OAuthClientAuthorizationList= new OAuthClientAuthorizationListBuilder(OAuthClientAuthorizationList); _visitables.add(this.OAuthClientAuthorizationList);} return (T) this;
    }
    public OAuthClientAuthorizationListNested withNewOAuthClientAuthorizationList(){
    return new OAuthClientAuthorizationListNested();
    }
    public OAuthClientAuthorizationListNested withNewOAuthClientAuthorizationListLike( OAuthClientAuthorizationList item){
    return new OAuthClientAuthorizationListNested(item);
    }
    public OAuthClientAuthorizationListNested editOAuthClientAuthorizationList(){
    return withNewOAuthClientAuthorizationListLike(getOAuthClientAuthorizationList());
    }
    public OAuthClientList getOAuthClientList(){
    return this.OAuthClientList!=null?this.OAuthClientList.build():null;
    }
    public T withOAuthClientList( OAuthClientList OAuthClientList){
    if (OAuthClientList!=null){ this.OAuthClientList= new OAuthClientListBuilder(OAuthClientList); _visitables.add(this.OAuthClientList);} return (T) this;
    }
    public OAuthClientListNested withNewOAuthClientList(){
    return new OAuthClientListNested();
    }
    public OAuthClientListNested withNewOAuthClientListLike( OAuthClientList item){
    return new OAuthClientListNested(item);
    }
    public OAuthClientListNested editOAuthClientList(){
    return withNewOAuthClientListLike(getOAuthClientList());
    }
    public ObjectMeta getObjectMeta(){
    return this.ObjectMeta!=null?this.ObjectMeta.build():null;
    }
    public T withObjectMeta( ObjectMeta ObjectMeta){
    if (ObjectMeta!=null){ this.ObjectMeta= new ObjectMetaBuilder(ObjectMeta); _visitables.add(this.ObjectMeta);} return (T) this;
    }
    public ObjectMetaNested withNewObjectMeta(){
    return new ObjectMetaNested();
    }
    public ObjectMetaNested withNewObjectMetaLike( ObjectMeta item){
    return new ObjectMetaNested(item);
    }
    public ObjectMetaNested editObjectMeta(){
    return withNewObjectMetaLike(getObjectMeta());
    }
    public PodList getPodList(){
    return this.PodList!=null?this.PodList.build():null;
    }
    public T withPodList( PodList PodList){
    if (PodList!=null){ this.PodList= new PodListBuilder(PodList); _visitables.add(this.PodList);} return (T) this;
    }
    public PodListNested withNewPodList(){
    return new PodListNested();
    }
    public PodListNested withNewPodListLike( PodList item){
    return new PodListNested(item);
    }
    public PodListNested editPodList(){
    return withNewPodListLike(getPodList());
    }
    public Quantity getQuantity(){
    return this.Quantity!=null?this.Quantity.build():null;
    }
    public T withQuantity( Quantity Quantity){
    if (Quantity!=null){ this.Quantity= new QuantityBuilder(Quantity); _visitables.add(this.Quantity);} return (T) this;
    }
    public QuantityNested withNewQuantity(){
    return new QuantityNested();
    }
    public QuantityNested withNewQuantityLike( Quantity item){
    return new QuantityNested(item);
    }
    public QuantityNested editQuantity(){
    return withNewQuantityLike(getQuantity());
    }
    public T withNewQuantity( String amount){
    return withQuantity(new Quantity(amount));
    }
    public T withNewQuantity( String amount,  String format){
    return withQuantity(new Quantity(amount, format));
    }
    public ReplicationControllerList getReplicationControllerList(){
    return this.ReplicationControllerList!=null?this.ReplicationControllerList.build():null;
    }
    public T withReplicationControllerList( ReplicationControllerList ReplicationControllerList){
    if (ReplicationControllerList!=null){ this.ReplicationControllerList= new ReplicationControllerListBuilder(ReplicationControllerList); _visitables.add(this.ReplicationControllerList);} return (T) this;
    }
    public ReplicationControllerListNested withNewReplicationControllerList(){
    return new ReplicationControllerListNested();
    }
    public ReplicationControllerListNested withNewReplicationControllerListLike( ReplicationControllerList item){
    return new ReplicationControllerListNested(item);
    }
    public ReplicationControllerListNested editReplicationControllerList(){
    return withNewReplicationControllerListLike(getReplicationControllerList());
    }
    public RouteList getRouteList(){
    return this.RouteList!=null?this.RouteList.build():null;
    }
    public T withRouteList( RouteList RouteList){
    if (RouteList!=null){ this.RouteList= new RouteListBuilder(RouteList); _visitables.add(this.RouteList);} return (T) this;
    }
    public RouteListNested withNewRouteList(){
    return new RouteListNested();
    }
    public RouteListNested withNewRouteListLike( RouteList item){
    return new RouteListNested(item);
    }
    public RouteListNested editRouteList(){
    return withNewRouteListLike(getRouteList());
    }
    public Secret getSecret(){
    return this.Secret!=null?this.Secret.build():null;
    }
    public T withSecret( Secret Secret){
    if (Secret!=null){ this.Secret= new SecretBuilder(Secret); _visitables.add(this.Secret);} return (T) this;
    }
    public SecretNested withNewSecret(){
    return new SecretNested();
    }
    public SecretNested withNewSecretLike( Secret item){
    return new SecretNested(item);
    }
    public SecretNested editSecret(){
    return withNewSecretLike(getSecret());
    }
    public SecretList getSecretList(){
    return this.SecretList!=null?this.SecretList.build():null;
    }
    public T withSecretList( SecretList SecretList){
    if (SecretList!=null){ this.SecretList= new SecretListBuilder(SecretList); _visitables.add(this.SecretList);} return (T) this;
    }
    public SecretListNested withNewSecretList(){
    return new SecretListNested();
    }
    public SecretListNested withNewSecretListLike( SecretList item){
    return new SecretListNested(item);
    }
    public SecretListNested editSecretList(){
    return withNewSecretListLike(getSecretList());
    }
    public ServiceAccount getServiceAccount(){
    return this.ServiceAccount!=null?this.ServiceAccount.build():null;
    }
    public T withServiceAccount( ServiceAccount ServiceAccount){
    if (ServiceAccount!=null){ this.ServiceAccount= new ServiceAccountBuilder(ServiceAccount); _visitables.add(this.ServiceAccount);} return (T) this;
    }
    public ServiceAccountNested withNewServiceAccount(){
    return new ServiceAccountNested();
    }
    public ServiceAccountNested withNewServiceAccountLike( ServiceAccount item){
    return new ServiceAccountNested(item);
    }
    public ServiceAccountNested editServiceAccount(){
    return withNewServiceAccountLike(getServiceAccount());
    }
    public ServiceAccountList getServiceAccountList(){
    return this.ServiceAccountList!=null?this.ServiceAccountList.build():null;
    }
    public T withServiceAccountList( ServiceAccountList ServiceAccountList){
    if (ServiceAccountList!=null){ this.ServiceAccountList= new ServiceAccountListBuilder(ServiceAccountList); _visitables.add(this.ServiceAccountList);} return (T) this;
    }
    public ServiceAccountListNested withNewServiceAccountList(){
    return new ServiceAccountListNested();
    }
    public ServiceAccountListNested withNewServiceAccountListLike( ServiceAccountList item){
    return new ServiceAccountListNested(item);
    }
    public ServiceAccountListNested editServiceAccountList(){
    return withNewServiceAccountListLike(getServiceAccountList());
    }
    public ServiceList getServiceList(){
    return this.ServiceList!=null?this.ServiceList.build():null;
    }
    public T withServiceList( ServiceList ServiceList){
    if (ServiceList!=null){ this.ServiceList= new ServiceListBuilder(ServiceList); _visitables.add(this.ServiceList);} return (T) this;
    }
    public ServiceListNested withNewServiceList(){
    return new ServiceListNested();
    }
    public ServiceListNested withNewServiceListLike( ServiceList item){
    return new ServiceListNested(item);
    }
    public ServiceListNested editServiceList(){
    return withNewServiceListLike(getServiceList());
    }
    public StatusError getStatusError(){
    return this.StatusError;
    }
    public T withStatusError( StatusError StatusError){
    this.StatusError=StatusError; return (T) this;
    }
    public TagEvent getTagEvent(){
    return this.TagEvent!=null?this.TagEvent.build():null;
    }
    public T withTagEvent( TagEvent TagEvent){
    if (TagEvent!=null){ this.TagEvent= new TagEventBuilder(TagEvent); _visitables.add(this.TagEvent);} return (T) this;
    }
    public TagEventNested withNewTagEvent(){
    return new TagEventNested();
    }
    public TagEventNested withNewTagEventLike( TagEvent item){
    return new TagEventNested(item);
    }
    public TagEventNested editTagEvent(){
    return withNewTagEventLike(getTagEvent());
    }
    public T withNewTagEvent( String created,  String dockerImageReference,  String image){
    return withTagEvent(new TagEvent(created, dockerImageReference, image));
    }
    public Template getTemplate(){
    return this.Template!=null?this.Template.build():null;
    }
    public T withTemplate( Template Template){
    if (Template!=null){ this.Template= new TemplateBuilder(Template); _visitables.add(this.Template);} return (T) this;
    }
    public TemplateNested withNewTemplate(){
    return new TemplateNested();
    }
    public TemplateNested withNewTemplateLike( Template item){
    return new TemplateNested(item);
    }
    public TemplateNested editTemplate(){
    return withNewTemplateLike(getTemplate());
    }
    public TemplateList getTemplateList(){
    return this.TemplateList;
    }
    public T withTemplateList( TemplateList TemplateList){
    this.TemplateList=TemplateList; return (T) this;
    }
    public WatchEvent getWatchEvent(){
    return this.WatchEvent;
    }
    public T withWatchEvent( WatchEvent WatchEvent){
    this.WatchEvent=WatchEvent; return (T) this;
    }
    public T addToAdditionalProperties( String key,  Object value){
    if(key != null && value != null) {this.additionalProperties.put(key, value);} return (T)this;
    }
    public Map getAdditionalProperties(){
    return this.additionalProperties;
    }
    public T withAdditionalProperties( Map additionalProperties){
    this.additionalProperties.clear();if (additionalProperties != null) {this.additionalProperties.putAll(additionalProperties);} return (T) this;
    }

    public class BaseKubernetesListNested extends BaseKubernetesListFluent> implements Nested{

        private final BaseKubernetesListBuilder builder;
    
             BaseKubernetesListNested ( BaseKubernetesList item){
        this.builder = new BaseKubernetesListBuilder(item);
        }
             BaseKubernetesListNested (){
        this.builder = new BaseKubernetesListBuilder(this);
        }
    
            public N endBaseKubernetesList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withBaseKubernetesList(builder.build());
        }
    
}
    public class BuildConfigListNested extends BuildConfigListFluent> implements Nested{

        private final BuildConfigListBuilder builder;
    
             BuildConfigListNested ( BuildConfigList item){
        this.builder = new BuildConfigListBuilder(item);
        }
             BuildConfigListNested (){
        this.builder = new BuildConfigListBuilder(this);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withBuildConfigList(builder.build());
        }
            public N endBuildConfigList(){
            return and();
        }
    
}
    public class BuildListNested extends BuildListFluent> implements Nested{

        private final BuildListBuilder builder;
    
             BuildListNested (){
        this.builder = new BuildListBuilder(this);
        }
             BuildListNested ( BuildList item){
        this.builder = new BuildListBuilder(item);
        }
    
            public N endBuildList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withBuildList(builder.build());
        }
    
}
    public class ContainerStatusNested extends ContainerStatusFluent> implements Nested{

        private final ContainerStatusBuilder builder;
    
             ContainerStatusNested ( ContainerStatus item){
        this.builder = new ContainerStatusBuilder(item);
        }
             ContainerStatusNested (){
        this.builder = new ContainerStatusBuilder(this);
        }
    
            public N endContainerStatus(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withContainerStatus(builder.build());
        }
    
}
    public class DeploymentConfigListNested extends DeploymentConfigListFluent> implements Nested{

        private final DeploymentConfigListBuilder builder;
    
             DeploymentConfigListNested ( DeploymentConfigList item){
        this.builder = new DeploymentConfigListBuilder(item);
        }
             DeploymentConfigListNested (){
        this.builder = new DeploymentConfigListBuilder(this);
        }
    
            public N endDeploymentConfigList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withDeploymentConfigList(builder.build());
        }
    
}
    public class EndpointsNested extends EndpointsFluent> implements Nested{

        private final EndpointsBuilder builder;
    
             EndpointsNested ( Endpoints item){
        this.builder = new EndpointsBuilder(item);
        }
             EndpointsNested (){
        this.builder = new EndpointsBuilder(this);
        }
    
            public N endEndpoints(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withEndpoints(builder.build());
        }
    
}
    public class EndpointsListNested extends EndpointsListFluent> implements Nested{

        private final EndpointsListBuilder builder;
    
             EndpointsListNested ( EndpointsList item){
        this.builder = new EndpointsListBuilder(item);
        }
             EndpointsListNested (){
        this.builder = new EndpointsListBuilder(this);
        }
    
            public N endEndpointsList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withEndpointsList(builder.build());
        }
    
}
    public class EnvVarNested extends EnvVarFluent> implements Nested{

        private final EnvVarBuilder builder;
    
             EnvVarNested ( EnvVar item){
        this.builder = new EnvVarBuilder(item);
        }
             EnvVarNested (){
        this.builder = new EnvVarBuilder(this);
        }
    
            public N endEnvVar(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withEnvVar(builder.build());
        }
    
}
    public class ImageListNested extends ImageListFluent> implements Nested{

        private final ImageListBuilder builder;
    
             ImageListNested (){
        this.builder = new ImageListBuilder(this);
        }
             ImageListNested ( ImageList item){
        this.builder = new ImageListBuilder(item);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withImageList(builder.build());
        }
            public N endImageList(){
            return and();
        }
    
}
    public class ImageStreamListNested extends ImageStreamListFluent> implements Nested{

        private final ImageStreamListBuilder builder;
    
             ImageStreamListNested ( ImageStreamList item){
        this.builder = new ImageStreamListBuilder(item);
        }
             ImageStreamListNested (){
        this.builder = new ImageStreamListBuilder(this);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withImageStreamList(builder.build());
        }
            public N endImageStreamList(){
            return and();
        }
    
}
    public class NamespaceNested extends NamespaceFluent> implements Nested{

        private final NamespaceBuilder builder;
    
             NamespaceNested ( Namespace item){
        this.builder = new NamespaceBuilder(item);
        }
             NamespaceNested (){
        this.builder = new NamespaceBuilder(this);
        }
    
            public N endNamespace(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withNamespace(builder.build());
        }
    
}
    public class NamespaceListNested extends NamespaceListFluent> implements Nested{

        private final NamespaceListBuilder builder;
    
             NamespaceListNested (){
        this.builder = new NamespaceListBuilder(this);
        }
             NamespaceListNested ( NamespaceList item){
        this.builder = new NamespaceListBuilder(item);
        }
    
            public N endNamespaceList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withNamespaceList(builder.build());
        }
    
}
    public class NodeNested extends NodeFluent> implements Nested{

        private final NodeBuilder builder;
    
             NodeNested ( Node item){
        this.builder = new NodeBuilder(item);
        }
             NodeNested (){
        this.builder = new NodeBuilder(this);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withNode(builder.build());
        }
            public N endNode(){
            return and();
        }
    
}
    public class NodeListNested extends NodeListFluent> implements Nested{

        private final NodeListBuilder builder;
    
             NodeListNested ( NodeList item){
        this.builder = new NodeListBuilder(item);
        }
             NodeListNested (){
        this.builder = new NodeListBuilder(this);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withNodeList(builder.build());
        }
            public N endNodeList(){
            return and();
        }
    
}
    public class OAuthAccessTokenNested extends OAuthAccessTokenFluent> implements Nested{

        private final OAuthAccessTokenBuilder builder;
    
             OAuthAccessTokenNested (){
        this.builder = new OAuthAccessTokenBuilder(this);
        }
             OAuthAccessTokenNested ( OAuthAccessToken item){
        this.builder = new OAuthAccessTokenBuilder(item);
        }
    
            public N endOAuthAccessToken(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthAccessToken(builder.build());
        }
    
}
    public class OAuthAccessTokenListNested extends OAuthAccessTokenListFluent> implements Nested{

        private final OAuthAccessTokenListBuilder builder;
    
             OAuthAccessTokenListNested (){
        this.builder = new OAuthAccessTokenListBuilder(this);
        }
             OAuthAccessTokenListNested ( OAuthAccessTokenList item){
        this.builder = new OAuthAccessTokenListBuilder(item);
        }
    
            public N endOAuthAccessTokenList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthAccessTokenList(builder.build());
        }
    
}
    public class OAuthAuthorizeTokenNested extends OAuthAuthorizeTokenFluent> implements Nested{

        private final OAuthAuthorizeTokenBuilder builder;
    
             OAuthAuthorizeTokenNested ( OAuthAuthorizeToken item){
        this.builder = new OAuthAuthorizeTokenBuilder(item);
        }
             OAuthAuthorizeTokenNested (){
        this.builder = new OAuthAuthorizeTokenBuilder(this);
        }
    
            public N endOAuthAuthorizeToken(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthAuthorizeToken(builder.build());
        }
    
}
    public class OAuthAuthorizeTokenListNested extends OAuthAuthorizeTokenListFluent> implements Nested{

        private final OAuthAuthorizeTokenListBuilder builder;
    
             OAuthAuthorizeTokenListNested (){
        this.builder = new OAuthAuthorizeTokenListBuilder(this);
        }
             OAuthAuthorizeTokenListNested ( OAuthAuthorizeTokenList item){
        this.builder = new OAuthAuthorizeTokenListBuilder(item);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthAuthorizeTokenList(builder.build());
        }
            public N endOAuthAuthorizeTokenList(){
            return and();
        }
    
}
    public class OAuthClientNested extends OAuthClientFluent> implements Nested{

        private final OAuthClientBuilder builder;
    
             OAuthClientNested ( OAuthClient item){
        this.builder = new OAuthClientBuilder(item);
        }
             OAuthClientNested (){
        this.builder = new OAuthClientBuilder(this);
        }
    
            public N endOAuthClient(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthClient(builder.build());
        }
    
}
    public class OAuthClientAuthorizationNested extends OAuthClientAuthorizationFluent> implements Nested{

        private final OAuthClientAuthorizationBuilder builder;
    
             OAuthClientAuthorizationNested ( OAuthClientAuthorization item){
        this.builder = new OAuthClientAuthorizationBuilder(item);
        }
             OAuthClientAuthorizationNested (){
        this.builder = new OAuthClientAuthorizationBuilder(this);
        }
    
            public N endOAuthClientAuthorization(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthClientAuthorization(builder.build());
        }
    
}
    public class OAuthClientAuthorizationListNested extends OAuthClientAuthorizationListFluent> implements Nested{

        private final OAuthClientAuthorizationListBuilder builder;
    
             OAuthClientAuthorizationListNested ( OAuthClientAuthorizationList item){
        this.builder = new OAuthClientAuthorizationListBuilder(item);
        }
             OAuthClientAuthorizationListNested (){
        this.builder = new OAuthClientAuthorizationListBuilder(this);
        }
    
            public N endOAuthClientAuthorizationList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthClientAuthorizationList(builder.build());
        }
    
}
    public class OAuthClientListNested extends OAuthClientListFluent> implements Nested{

        private final OAuthClientListBuilder builder;
    
             OAuthClientListNested ( OAuthClientList item){
        this.builder = new OAuthClientListBuilder(item);
        }
             OAuthClientListNested (){
        this.builder = new OAuthClientListBuilder(this);
        }
    
            public N endOAuthClientList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withOAuthClientList(builder.build());
        }
    
}
    public class ObjectMetaNested extends ObjectMetaFluent> implements Nested{

        private final ObjectMetaBuilder builder;
    
             ObjectMetaNested (){
        this.builder = new ObjectMetaBuilder(this);
        }
             ObjectMetaNested ( ObjectMeta item){
        this.builder = new ObjectMetaBuilder(item);
        }
    
            public N endObjectMeta(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withObjectMeta(builder.build());
        }
    
}
    public class PodListNested extends PodListFluent> implements Nested{

        private final PodListBuilder builder;
    
             PodListNested ( PodList item){
        this.builder = new PodListBuilder(item);
        }
             PodListNested (){
        this.builder = new PodListBuilder(this);
        }
    
            public N endPodList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withPodList(builder.build());
        }
    
}
    public class QuantityNested extends QuantityFluent> implements Nested{

        private final QuantityBuilder builder;
    
             QuantityNested (){
        this.builder = new QuantityBuilder(this);
        }
             QuantityNested ( Quantity item){
        this.builder = new QuantityBuilder(item);
        }
    
            public N endQuantity(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withQuantity(builder.build());
        }
    
}
    public class ReplicationControllerListNested extends ReplicationControllerListFluent> implements Nested{

        private final ReplicationControllerListBuilder builder;
    
             ReplicationControllerListNested (){
        this.builder = new ReplicationControllerListBuilder(this);
        }
             ReplicationControllerListNested ( ReplicationControllerList item){
        this.builder = new ReplicationControllerListBuilder(item);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withReplicationControllerList(builder.build());
        }
            public N endReplicationControllerList(){
            return and();
        }
    
}
    public class RouteListNested extends RouteListFluent> implements Nested{

        private final RouteListBuilder builder;
    
             RouteListNested ( RouteList item){
        this.builder = new RouteListBuilder(item);
        }
             RouteListNested (){
        this.builder = new RouteListBuilder(this);
        }
    
            public N endRouteList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withRouteList(builder.build());
        }
    
}
    public class SecretNested extends SecretFluent> implements Nested{

        private final SecretBuilder builder;
    
             SecretNested (){
        this.builder = new SecretBuilder(this);
        }
             SecretNested ( Secret item){
        this.builder = new SecretBuilder(item);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withSecret(builder.build());
        }
            public N endSecret(){
            return and();
        }
    
}
    public class SecretListNested extends SecretListFluent> implements Nested{

        private final SecretListBuilder builder;
    
             SecretListNested ( SecretList item){
        this.builder = new SecretListBuilder(item);
        }
             SecretListNested (){
        this.builder = new SecretListBuilder(this);
        }
    
            public N endSecretList(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withSecretList(builder.build());
        }
    
}
    public class ServiceAccountNested extends ServiceAccountFluent> implements Nested{

        private final ServiceAccountBuilder builder;
    
             ServiceAccountNested (){
        this.builder = new ServiceAccountBuilder(this);
        }
             ServiceAccountNested ( ServiceAccount item){
        this.builder = new ServiceAccountBuilder(item);
        }
    
            public N endServiceAccount(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withServiceAccount(builder.build());
        }
    
}
    public class ServiceAccountListNested extends ServiceAccountListFluent> implements Nested{

        private final ServiceAccountListBuilder builder;
    
             ServiceAccountListNested ( ServiceAccountList item){
        this.builder = new ServiceAccountListBuilder(item);
        }
             ServiceAccountListNested (){
        this.builder = new ServiceAccountListBuilder(this);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withServiceAccountList(builder.build());
        }
            public N endServiceAccountList(){
            return and();
        }
    
}
    public class ServiceListNested extends ServiceListFluent> implements Nested{

        private final ServiceListBuilder builder;
    
             ServiceListNested (){
        this.builder = new ServiceListBuilder(this);
        }
             ServiceListNested ( ServiceList item){
        this.builder = new ServiceListBuilder(item);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withServiceList(builder.build());
        }
            public N endServiceList(){
            return and();
        }
    
}
    public class TagEventNested extends TagEventFluent> implements Nested{

        private final TagEventBuilder builder;
    
             TagEventNested (){
        this.builder = new TagEventBuilder(this);
        }
             TagEventNested ( TagEvent item){
        this.builder = new TagEventBuilder(item);
        }
    
            public N and(){
            return (N) KubeSchemaFluent.this.withTagEvent(builder.build());
        }
            public N endTagEvent(){
            return and();
        }
    
}
    public class TemplateNested extends TemplateFluent> implements Nested{

        private final TemplateBuilder builder;
    
             TemplateNested (){
        this.builder = new TemplateBuilder(this);
        }
             TemplateNested ( Template item){
        this.builder = new TemplateBuilder(item);
        }
    
            public N endTemplate(){
            return and();
        }
            public N and(){
            return (N) KubeSchemaFluent.this.withTemplate(builder.build());
        }
    
}


}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy