io.alauda.kubernetes.api.model.NamedExtensionFluentImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of kubernetes-model Show documentation
There is a newer version: 0.2.12
package io.alauda.kubernetes.api.model;

import java.lang.String;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.StatefulSetBuilder;
import java.lang.Deprecated;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicy;
import io.alauda.kubernetes.api.model.extensions.ReplicaSet;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewFluentImpl;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReviewFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ScaleFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.Deployment;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSet;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyFluentImpl;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.IngressBuilder;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.alauda.kubernetes.api.builder.BaseFluent;
import java.lang.Boolean;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicy;
import io.alauda.kubernetes.api.model.extensions.DaemonSetFluentImpl;
import javax.validation.Valid;
import java.lang.Object;
import io.alauda.kubernetes.api.model.extensions.DeploymentBuilder;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResource;
import io.alauda.kubernetes.api.model.authentication.TokenReviewBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReview;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionBuilder;
import io.alauda.kubernetes.api.builder.VisitableBuilder;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetBuilder;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceBuilder;
import io.alauda.kubernetes.api.model.extensions.ScaleBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyFluentImpl;
import io.alauda.kubernetes.api.model.extensions.Ingress;
import io.alauda.kubernetes.api.model.extensions.StatefulSet;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudget;
import io.alauda.kubernetes.api.builder.Nested;
import io.alauda.kubernetes.api.model.extensions.DaemonSetBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinition;
import io.alauda.kubernetes.api.model.extensions.Scale;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyBuilder;

public class NamedExtensionFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements NamedExtensionFluent{

    private VisitableBuilder extension;
    private String name;

    public NamedExtensionFluentImpl(){
    }
    public NamedExtensionFluentImpl(NamedExtension instance){
            this.withExtension(instance.getExtension()); 
            this.withName(instance.getName()); 
    }

    
/**
 * This method has been deprecated, please use method buildExtension instead.
 */
@Deprecated public HasMetadata getExtension(){
            return this.extension!=null?this.extension.build():null;
    }

    public HasMetadata buildExtension(){
            return this.extension!=null?this.extension.build():null;
    }

    public A withExtension(HasMetadata extension){
            if (extension instanceof Binding){ this.extension= new BindingBuilder((Binding)extension); _visitables.add(this.extension);}
            if (extension instanceof Ingress){ this.extension= new IngressBuilder((Ingress)extension); _visitables.add(this.extension);}
            if (extension instanceof LocalSubjectAccessReview){ this.extension= new LocalSubjectAccessReviewBuilder((LocalSubjectAccessReview)extension); _visitables.add(this.extension);}
            if (extension instanceof StatefulSet){ this.extension= new StatefulSetBuilder((StatefulSet)extension); _visitables.add(this.extension);}
            if (extension instanceof PipelineTemplateTaskInstance){ this.extension= new PipelineTemplateTaskInstanceBuilder((PipelineTemplateTaskInstance)extension); _visitables.add(this.extension);}
            if (extension instanceof PodSecurityPolicy){ this.extension= new PodSecurityPolicyBuilder((PodSecurityPolicy)extension); _visitables.add(this.extension);}
            if (extension instanceof Pipeline){ this.extension= new PipelineBuilder((Pipeline)extension); _visitables.add(this.extension);}
            if (extension instanceof ResourceQuota){ this.extension= new ResourceQuotaBuilder((ResourceQuota)extension); _visitables.add(this.extension);}
            if (extension instanceof ServiceAccount){ this.extension= new ServiceAccountBuilder((ServiceAccount)extension); _visitables.add(this.extension);}
            if (extension instanceof ConfigMap){ this.extension= new ConfigMapBuilder((ConfigMap)extension); _visitables.add(this.extension);}
            if (extension instanceof JenkinsBinding){ this.extension= new JenkinsBindingBuilder((JenkinsBinding)extension); _visitables.add(this.extension);}
            if (extension instanceof PipelineTemplate){ this.extension= new PipelineTemplateBuilder((PipelineTemplate)extension); _visitables.add(this.extension);}
            if (extension instanceof CronJob){ this.extension= new CronJobBuilder((CronJob)extension); _visitables.add(this.extension);}
            if (extension instanceof SubjectAccessReview){ this.extension= new SubjectAccessReviewBuilder((SubjectAccessReview)extension); _visitables.add(this.extension);}
            if (extension instanceof PodTemplate){ this.extension= new PodTemplateBuilder((PodTemplate)extension); _visitables.add(this.extension);}
            if (extension instanceof TokenReview){ this.extension= new TokenReviewBuilder((TokenReview)extension); _visitables.add(this.extension);}
            if (extension instanceof CustomResourceDefinition){ this.extension= new CustomResourceDefinitionBuilder((CustomResourceDefinition)extension); _visitables.add(this.extension);}
            if (extension instanceof StorageClass){ this.extension= new StorageClassBuilder((StorageClass)extension); _visitables.add(this.extension);}
            if (extension instanceof PipelineConfigTemplate){ this.extension= new PipelineConfigTemplateBuilder((PipelineConfigTemplate)extension); _visitables.add(this.extension);}
            if (extension instanceof Namespace){ this.extension= new NamespaceBuilder((Namespace)extension); _visitables.add(this.extension);}
            if (extension instanceof PipelineConfig){ this.extension= new PipelineConfigBuilder((PipelineConfig)extension); _visitables.add(this.extension);}
            if (extension instanceof CodeRepoService){ this.extension= new CodeRepoServiceBuilder((CodeRepoService)extension); _visitables.add(this.extension);}
            if (extension instanceof CodeRepoBinding){ this.extension= new CodeRepoBindingBuilder((CodeRepoBinding)extension); _visitables.add(this.extension);}
            if (extension instanceof Scale){ this.extension= new ScaleBuilder((Scale)extension); _visitables.add(this.extension);}
            if (extension instanceof PipelineTaskTemplate){ this.extension= new PipelineTaskTemplateBuilder((PipelineTaskTemplate)extension); _visitables.add(this.extension);}
            if (extension instanceof Pod){ this.extension= new PodBuilder((Pod)extension); _visitables.add(this.extension);}
            if (extension instanceof HorizontalPodAutoscaler){ this.extension= new HorizontalPodAutoscalerBuilder((HorizontalPodAutoscaler)extension); _visitables.add(this.extension);}
            if (extension instanceof ThirdPartyResource){ this.extension= new ThirdPartyResourceBuilder((ThirdPartyResource)extension); _visitables.add(this.extension);}
            if (extension instanceof ComponentStatus){ this.extension= new ComponentStatusBuilder((ComponentStatus)extension); _visitables.add(this.extension);}
            if (extension instanceof PersistentVolumeClaim){ this.extension= new PersistentVolumeClaimBuilder((PersistentVolumeClaim)extension); _visitables.add(this.extension);}
            if (extension instanceof Secret){ this.extension= new SecretBuilder((Secret)extension); _visitables.add(this.extension);}
            if (extension instanceof ReplicationController){ this.extension= new ReplicationControllerBuilder((ReplicationController)extension); _visitables.add(this.extension);}
            if (extension instanceof Endpoints){ this.extension= new EndpointsBuilder((Endpoints)extension); _visitables.add(this.extension);}
            if (extension instanceof LimitRange){ this.extension= new LimitRangeBuilder((LimitRange)extension); _visitables.add(this.extension);}
            if (extension instanceof NetworkPolicy){ this.extension= new NetworkPolicyBuilder((NetworkPolicy)extension); _visitables.add(this.extension);}
            if (extension instanceof Service){ this.extension= new ServiceBuilder((Service)extension); _visitables.add(this.extension);}
            if (extension instanceof Event){ this.extension= new EventBuilder((Event)extension); _visitables.add(this.extension);}
            if (extension instanceof Node){ this.extension= new NodeBuilder((Node)extension); _visitables.add(this.extension);}
            if (extension instanceof ReplicaSet){ this.extension= new ReplicaSetBuilder((ReplicaSet)extension); _visitables.add(this.extension);}
            if (extension instanceof ClusterPipelineTemplate){ this.extension= new ClusterPipelineTemplateBuilder((ClusterPipelineTemplate)extension); _visitables.add(this.extension);}
            if (extension instanceof Job){ this.extension= new JobBuilder((Job)extension); _visitables.add(this.extension);}
            if (extension instanceof ClusterPipelineTaskTemplate){ this.extension= new ClusterPipelineTaskTemplateBuilder((ClusterPipelineTaskTemplate)extension); _visitables.add(this.extension);}
            if (extension instanceof Deployment){ this.extension= new DeploymentBuilder((Deployment)extension); _visitables.add(this.extension);}
            if (extension instanceof Jenkins){ this.extension= new JenkinsBuilder((Jenkins)extension); _visitables.add(this.extension);}
            if (extension instanceof DaemonSet){ this.extension= new DaemonSetBuilder((DaemonSet)extension); _visitables.add(this.extension);}
            if (extension instanceof PodDisruptionBudget){ this.extension= new PodDisruptionBudgetBuilder((PodDisruptionBudget)extension); _visitables.add(this.extension);}
            if (extension instanceof Project){ this.extension= new ProjectBuilder((Project)extension); _visitables.add(this.extension);}
            if (extension instanceof PersistentVolume){ this.extension= new PersistentVolumeBuilder((PersistentVolume)extension); _visitables.add(this.extension);}
            if (extension instanceof CodeRepository){ this.extension= new CodeRepositoryBuilder((CodeRepository)extension); _visitables.add(this.extension);}
            return (A) this;
    }

    public Boolean hasExtension(){
            return this.extension!=null;
    }

    public A withBindingExtension(Binding bindingExtension){
            _visitables.remove(this.extension);
            if (bindingExtension!=null){ this.extension= new BindingBuilder(bindingExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.BindingExtensionNested withNewBindingExtension(){
            return new BindingExtensionNestedImpl();
    }

    public NamedExtensionFluent.BindingExtensionNested withNewBindingExtensionLike(Binding item){
            return new BindingExtensionNestedImpl(item);
    }

    public A withIngressExtension(Ingress ingressExtension){
            _visitables.remove(this.extension);
            if (ingressExtension!=null){ this.extension= new IngressBuilder(ingressExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.IngressExtensionNested withNewIngressExtension(){
            return new IngressExtensionNestedImpl();
    }

    public NamedExtensionFluent.IngressExtensionNested withNewIngressExtensionLike(Ingress item){
            return new IngressExtensionNestedImpl(item);
    }

    public A withLocalSubjectAccessReviewExtension(LocalSubjectAccessReview localSubjectAccessReviewExtension){
            _visitables.remove(this.extension);
            if (localSubjectAccessReviewExtension!=null){ this.extension= new LocalSubjectAccessReviewBuilder(localSubjectAccessReviewExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.LocalSubjectAccessReviewExtensionNested withNewLocalSubjectAccessReviewExtension(){
            return new LocalSubjectAccessReviewExtensionNestedImpl();
    }

    public NamedExtensionFluent.LocalSubjectAccessReviewExtensionNested withNewLocalSubjectAccessReviewExtensionLike(LocalSubjectAccessReview item){
            return new LocalSubjectAccessReviewExtensionNestedImpl(item);
    }

    public A withStatefulSetExtension(StatefulSet statefulSetExtension){
            _visitables.remove(this.extension);
            if (statefulSetExtension!=null){ this.extension= new StatefulSetBuilder(statefulSetExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.StatefulSetExtensionNested withNewStatefulSetExtension(){
            return new StatefulSetExtensionNestedImpl();
    }

    public NamedExtensionFluent.StatefulSetExtensionNested withNewStatefulSetExtensionLike(StatefulSet item){
            return new StatefulSetExtensionNestedImpl(item);
    }

    public A withPipelineTemplateTaskInstanceExtension(PipelineTemplateTaskInstance pipelineTemplateTaskInstanceExtension){
            _visitables.remove(this.extension);
            if (pipelineTemplateTaskInstanceExtension!=null){ this.extension= new PipelineTemplateTaskInstanceBuilder(pipelineTemplateTaskInstanceExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PipelineTemplateTaskInstanceExtensionNested withNewPipelineTemplateTaskInstanceExtension(){
            return new PipelineTemplateTaskInstanceExtensionNestedImpl();
    }

    public NamedExtensionFluent.PipelineTemplateTaskInstanceExtensionNested withNewPipelineTemplateTaskInstanceExtensionLike(PipelineTemplateTaskInstance item){
            return new PipelineTemplateTaskInstanceExtensionNestedImpl(item);
    }

    public A withPodSecurityPolicyExtension(PodSecurityPolicy podSecurityPolicyExtension){
            _visitables.remove(this.extension);
            if (podSecurityPolicyExtension!=null){ this.extension= new PodSecurityPolicyBuilder(podSecurityPolicyExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PodSecurityPolicyExtensionNested withNewPodSecurityPolicyExtension(){
            return new PodSecurityPolicyExtensionNestedImpl();
    }

    public NamedExtensionFluent.PodSecurityPolicyExtensionNested withNewPodSecurityPolicyExtensionLike(PodSecurityPolicy item){
            return new PodSecurityPolicyExtensionNestedImpl(item);
    }

    public A withPipelineExtension(Pipeline pipelineExtension){
            _visitables.remove(this.extension);
            if (pipelineExtension!=null){ this.extension= new PipelineBuilder(pipelineExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PipelineExtensionNested withNewPipelineExtension(){
            return new PipelineExtensionNestedImpl();
    }

    public NamedExtensionFluent.PipelineExtensionNested withNewPipelineExtensionLike(Pipeline item){
            return new PipelineExtensionNestedImpl(item);
    }

    public A withResourceQuotaExtension(ResourceQuota resourceQuotaExtension){
            _visitables.remove(this.extension);
            if (resourceQuotaExtension!=null){ this.extension= new ResourceQuotaBuilder(resourceQuotaExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ResourceQuotaExtensionNested withNewResourceQuotaExtension(){
            return new ResourceQuotaExtensionNestedImpl();
    }

    public NamedExtensionFluent.ResourceQuotaExtensionNested withNewResourceQuotaExtensionLike(ResourceQuota item){
            return new ResourceQuotaExtensionNestedImpl(item);
    }

    public A withServiceAccountExtension(ServiceAccount serviceAccountExtension){
            _visitables.remove(this.extension);
            if (serviceAccountExtension!=null){ this.extension= new ServiceAccountBuilder(serviceAccountExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ServiceAccountExtensionNested withNewServiceAccountExtension(){
            return new ServiceAccountExtensionNestedImpl();
    }

    public NamedExtensionFluent.ServiceAccountExtensionNested withNewServiceAccountExtensionLike(ServiceAccount item){
            return new ServiceAccountExtensionNestedImpl(item);
    }

    public A withConfigMapExtension(ConfigMap configMapExtension){
            _visitables.remove(this.extension);
            if (configMapExtension!=null){ this.extension= new ConfigMapBuilder(configMapExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ConfigMapExtensionNested withNewConfigMapExtension(){
            return new ConfigMapExtensionNestedImpl();
    }

    public NamedExtensionFluent.ConfigMapExtensionNested withNewConfigMapExtensionLike(ConfigMap item){
            return new ConfigMapExtensionNestedImpl(item);
    }

    public A withJenkinsBindingExtension(JenkinsBinding jenkinsBindingExtension){
            _visitables.remove(this.extension);
            if (jenkinsBindingExtension!=null){ this.extension= new JenkinsBindingBuilder(jenkinsBindingExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.JenkinsBindingExtensionNested withNewJenkinsBindingExtension(){
            return new JenkinsBindingExtensionNestedImpl();
    }

    public NamedExtensionFluent.JenkinsBindingExtensionNested withNewJenkinsBindingExtensionLike(JenkinsBinding item){
            return new JenkinsBindingExtensionNestedImpl(item);
    }

    public A withPipelineTemplateExtension(PipelineTemplate pipelineTemplateExtension){
            _visitables.remove(this.extension);
            if (pipelineTemplateExtension!=null){ this.extension= new PipelineTemplateBuilder(pipelineTemplateExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PipelineTemplateExtensionNested withNewPipelineTemplateExtension(){
            return new PipelineTemplateExtensionNestedImpl();
    }

    public NamedExtensionFluent.PipelineTemplateExtensionNested withNewPipelineTemplateExtensionLike(PipelineTemplate item){
            return new PipelineTemplateExtensionNestedImpl(item);
    }

    public A withCronJobExtension(CronJob cronJobExtension){
            _visitables.remove(this.extension);
            if (cronJobExtension!=null){ this.extension= new CronJobBuilder(cronJobExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.CronJobExtensionNested withNewCronJobExtension(){
            return new CronJobExtensionNestedImpl();
    }

    public NamedExtensionFluent.CronJobExtensionNested withNewCronJobExtensionLike(CronJob item){
            return new CronJobExtensionNestedImpl(item);
    }

    public A withSubjectAccessReviewExtension(SubjectAccessReview subjectAccessReviewExtension){
            _visitables.remove(this.extension);
            if (subjectAccessReviewExtension!=null){ this.extension= new SubjectAccessReviewBuilder(subjectAccessReviewExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.SubjectAccessReviewExtensionNested withNewSubjectAccessReviewExtension(){
            return new SubjectAccessReviewExtensionNestedImpl();
    }

    public NamedExtensionFluent.SubjectAccessReviewExtensionNested withNewSubjectAccessReviewExtensionLike(SubjectAccessReview item){
            return new SubjectAccessReviewExtensionNestedImpl(item);
    }

    public A withPodTemplateExtension(PodTemplate podTemplateExtension){
            _visitables.remove(this.extension);
            if (podTemplateExtension!=null){ this.extension= new PodTemplateBuilder(podTemplateExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PodTemplateExtensionNested withNewPodTemplateExtension(){
            return new PodTemplateExtensionNestedImpl();
    }

    public NamedExtensionFluent.PodTemplateExtensionNested withNewPodTemplateExtensionLike(PodTemplate item){
            return new PodTemplateExtensionNestedImpl(item);
    }

    public A withTokenReviewExtension(TokenReview tokenReviewExtension){
            _visitables.remove(this.extension);
            if (tokenReviewExtension!=null){ this.extension= new TokenReviewBuilder(tokenReviewExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.TokenReviewExtensionNested withNewTokenReviewExtension(){
            return new TokenReviewExtensionNestedImpl();
    }

    public NamedExtensionFluent.TokenReviewExtensionNested withNewTokenReviewExtensionLike(TokenReview item){
            return new TokenReviewExtensionNestedImpl(item);
    }

    public A withCustomResourceDefinitionExtension(CustomResourceDefinition customResourceDefinitionExtension){
            _visitables.remove(this.extension);
            if (customResourceDefinitionExtension!=null){ this.extension= new CustomResourceDefinitionBuilder(customResourceDefinitionExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.CustomResourceDefinitionExtensionNested withNewCustomResourceDefinitionExtension(){
            return new CustomResourceDefinitionExtensionNestedImpl();
    }

    public NamedExtensionFluent.CustomResourceDefinitionExtensionNested withNewCustomResourceDefinitionExtensionLike(CustomResourceDefinition item){
            return new CustomResourceDefinitionExtensionNestedImpl(item);
    }

    public A withStorageClassExtension(StorageClass storageClassExtension){
            _visitables.remove(this.extension);
            if (storageClassExtension!=null){ this.extension= new StorageClassBuilder(storageClassExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.StorageClassExtensionNested withNewStorageClassExtension(){
            return new StorageClassExtensionNestedImpl();
    }

    public NamedExtensionFluent.StorageClassExtensionNested withNewStorageClassExtensionLike(StorageClass item){
            return new StorageClassExtensionNestedImpl(item);
    }

    public A withPipelineConfigTemplateExtension(PipelineConfigTemplate pipelineConfigTemplateExtension){
            _visitables.remove(this.extension);
            if (pipelineConfigTemplateExtension!=null){ this.extension= new PipelineConfigTemplateBuilder(pipelineConfigTemplateExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PipelineConfigTemplateExtensionNested withNewPipelineConfigTemplateExtension(){
            return new PipelineConfigTemplateExtensionNestedImpl();
    }

    public NamedExtensionFluent.PipelineConfigTemplateExtensionNested withNewPipelineConfigTemplateExtensionLike(PipelineConfigTemplate item){
            return new PipelineConfigTemplateExtensionNestedImpl(item);
    }

    public A withNamespaceExtension(Namespace namespaceExtension){
            _visitables.remove(this.extension);
            if (namespaceExtension!=null){ this.extension= new NamespaceBuilder(namespaceExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.NamespaceExtensionNested withNewNamespaceExtension(){
            return new NamespaceExtensionNestedImpl();
    }

    public NamedExtensionFluent.NamespaceExtensionNested withNewNamespaceExtensionLike(Namespace item){
            return new NamespaceExtensionNestedImpl(item);
    }

    public A withPipelineConfigExtension(PipelineConfig pipelineConfigExtension){
            _visitables.remove(this.extension);
            if (pipelineConfigExtension!=null){ this.extension= new PipelineConfigBuilder(pipelineConfigExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PipelineConfigExtensionNested withNewPipelineConfigExtension(){
            return new PipelineConfigExtensionNestedImpl();
    }

    public NamedExtensionFluent.PipelineConfigExtensionNested withNewPipelineConfigExtensionLike(PipelineConfig item){
            return new PipelineConfigExtensionNestedImpl(item);
    }

    public A withCodeRepoServiceExtension(CodeRepoService codeRepoServiceExtension){
            _visitables.remove(this.extension);
            if (codeRepoServiceExtension!=null){ this.extension= new CodeRepoServiceBuilder(codeRepoServiceExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.CodeRepoServiceExtensionNested withNewCodeRepoServiceExtension(){
            return new CodeRepoServiceExtensionNestedImpl();
    }

    public NamedExtensionFluent.CodeRepoServiceExtensionNested withNewCodeRepoServiceExtensionLike(CodeRepoService item){
            return new CodeRepoServiceExtensionNestedImpl(item);
    }

    public A withCodeRepoBindingExtension(CodeRepoBinding codeRepoBindingExtension){
            _visitables.remove(this.extension);
            if (codeRepoBindingExtension!=null){ this.extension= new CodeRepoBindingBuilder(codeRepoBindingExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.CodeRepoBindingExtensionNested withNewCodeRepoBindingExtension(){
            return new CodeRepoBindingExtensionNestedImpl();
    }

    public NamedExtensionFluent.CodeRepoBindingExtensionNested withNewCodeRepoBindingExtensionLike(CodeRepoBinding item){
            return new CodeRepoBindingExtensionNestedImpl(item);
    }

    public A withScaleExtension(Scale scaleExtension){
            _visitables.remove(this.extension);
            if (scaleExtension!=null){ this.extension= new ScaleBuilder(scaleExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ScaleExtensionNested withNewScaleExtension(){
            return new ScaleExtensionNestedImpl();
    }

    public NamedExtensionFluent.ScaleExtensionNested withNewScaleExtensionLike(Scale item){
            return new ScaleExtensionNestedImpl(item);
    }

    public A withPipelineTaskTemplateExtension(PipelineTaskTemplate pipelineTaskTemplateExtension){
            _visitables.remove(this.extension);
            if (pipelineTaskTemplateExtension!=null){ this.extension= new PipelineTaskTemplateBuilder(pipelineTaskTemplateExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PipelineTaskTemplateExtensionNested withNewPipelineTaskTemplateExtension(){
            return new PipelineTaskTemplateExtensionNestedImpl();
    }

    public NamedExtensionFluent.PipelineTaskTemplateExtensionNested withNewPipelineTaskTemplateExtensionLike(PipelineTaskTemplate item){
            return new PipelineTaskTemplateExtensionNestedImpl(item);
    }

    public A withPodExtension(Pod podExtension){
            _visitables.remove(this.extension);
            if (podExtension!=null){ this.extension= new PodBuilder(podExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PodExtensionNested withNewPodExtension(){
            return new PodExtensionNestedImpl();
    }

    public NamedExtensionFluent.PodExtensionNested withNewPodExtensionLike(Pod item){
            return new PodExtensionNestedImpl(item);
    }

    public A withHorizontalPodAutoscalerExtension(HorizontalPodAutoscaler horizontalPodAutoscalerExtension){
            _visitables.remove(this.extension);
            if (horizontalPodAutoscalerExtension!=null){ this.extension= new HorizontalPodAutoscalerBuilder(horizontalPodAutoscalerExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.HorizontalPodAutoscalerExtensionNested withNewHorizontalPodAutoscalerExtension(){
            return new HorizontalPodAutoscalerExtensionNestedImpl();
    }

    public NamedExtensionFluent.HorizontalPodAutoscalerExtensionNested withNewHorizontalPodAutoscalerExtensionLike(HorizontalPodAutoscaler item){
            return new HorizontalPodAutoscalerExtensionNestedImpl(item);
    }

    public A withThirdPartyResourceExtension(ThirdPartyResource thirdPartyResourceExtension){
            _visitables.remove(this.extension);
            if (thirdPartyResourceExtension!=null){ this.extension= new ThirdPartyResourceBuilder(thirdPartyResourceExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ThirdPartyResourceExtensionNested withNewThirdPartyResourceExtension(){
            return new ThirdPartyResourceExtensionNestedImpl();
    }

    public NamedExtensionFluent.ThirdPartyResourceExtensionNested withNewThirdPartyResourceExtensionLike(ThirdPartyResource item){
            return new ThirdPartyResourceExtensionNestedImpl(item);
    }

    public A withComponentStatusExtension(ComponentStatus componentStatusExtension){
            _visitables.remove(this.extension);
            if (componentStatusExtension!=null){ this.extension= new ComponentStatusBuilder(componentStatusExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ComponentStatusExtensionNested withNewComponentStatusExtension(){
            return new ComponentStatusExtensionNestedImpl();
    }

    public NamedExtensionFluent.ComponentStatusExtensionNested withNewComponentStatusExtensionLike(ComponentStatus item){
            return new ComponentStatusExtensionNestedImpl(item);
    }

    public A withPersistentVolumeClaimExtension(PersistentVolumeClaim persistentVolumeClaimExtension){
            _visitables.remove(this.extension);
            if (persistentVolumeClaimExtension!=null){ this.extension= new PersistentVolumeClaimBuilder(persistentVolumeClaimExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PersistentVolumeClaimExtensionNested withNewPersistentVolumeClaimExtension(){
            return new PersistentVolumeClaimExtensionNestedImpl();
    }

    public NamedExtensionFluent.PersistentVolumeClaimExtensionNested withNewPersistentVolumeClaimExtensionLike(PersistentVolumeClaim item){
            return new PersistentVolumeClaimExtensionNestedImpl(item);
    }

    public A withSecretExtension(Secret secretExtension){
            _visitables.remove(this.extension);
            if (secretExtension!=null){ this.extension= new SecretBuilder(secretExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.SecretExtensionNested withNewSecretExtension(){
            return new SecretExtensionNestedImpl();
    }

    public NamedExtensionFluent.SecretExtensionNested withNewSecretExtensionLike(Secret item){
            return new SecretExtensionNestedImpl(item);
    }

    public A withReplicationControllerExtension(ReplicationController replicationControllerExtension){
            _visitables.remove(this.extension);
            if (replicationControllerExtension!=null){ this.extension= new ReplicationControllerBuilder(replicationControllerExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ReplicationControllerExtensionNested withNewReplicationControllerExtension(){
            return new ReplicationControllerExtensionNestedImpl();
    }

    public NamedExtensionFluent.ReplicationControllerExtensionNested withNewReplicationControllerExtensionLike(ReplicationController item){
            return new ReplicationControllerExtensionNestedImpl(item);
    }

    public A withEndpointsExtension(Endpoints endpointsExtension){
            _visitables.remove(this.extension);
            if (endpointsExtension!=null){ this.extension= new EndpointsBuilder(endpointsExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.EndpointsExtensionNested withNewEndpointsExtension(){
            return new EndpointsExtensionNestedImpl();
    }

    public NamedExtensionFluent.EndpointsExtensionNested withNewEndpointsExtensionLike(Endpoints item){
            return new EndpointsExtensionNestedImpl(item);
    }

    public A withLimitRangeExtension(LimitRange limitRangeExtension){
            _visitables.remove(this.extension);
            if (limitRangeExtension!=null){ this.extension= new LimitRangeBuilder(limitRangeExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.LimitRangeExtensionNested withNewLimitRangeExtension(){
            return new LimitRangeExtensionNestedImpl();
    }

    public NamedExtensionFluent.LimitRangeExtensionNested withNewLimitRangeExtensionLike(LimitRange item){
            return new LimitRangeExtensionNestedImpl(item);
    }

    public A withNetworkPolicyExtension(NetworkPolicy networkPolicyExtension){
            _visitables.remove(this.extension);
            if (networkPolicyExtension!=null){ this.extension= new NetworkPolicyBuilder(networkPolicyExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.NetworkPolicyExtensionNested withNewNetworkPolicyExtension(){
            return new NetworkPolicyExtensionNestedImpl();
    }

    public NamedExtensionFluent.NetworkPolicyExtensionNested withNewNetworkPolicyExtensionLike(NetworkPolicy item){
            return new NetworkPolicyExtensionNestedImpl(item);
    }

    public A withServiceExtension(Service serviceExtension){
            _visitables.remove(this.extension);
            if (serviceExtension!=null){ this.extension= new ServiceBuilder(serviceExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ServiceExtensionNested withNewServiceExtension(){
            return new ServiceExtensionNestedImpl();
    }

    public NamedExtensionFluent.ServiceExtensionNested withNewServiceExtensionLike(Service item){
            return new ServiceExtensionNestedImpl(item);
    }

    public A withEventExtension(Event eventExtension){
            _visitables.remove(this.extension);
            if (eventExtension!=null){ this.extension= new EventBuilder(eventExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.EventExtensionNested withNewEventExtension(){
            return new EventExtensionNestedImpl();
    }

    public NamedExtensionFluent.EventExtensionNested withNewEventExtensionLike(Event item){
            return new EventExtensionNestedImpl(item);
    }

    public A withNodeExtension(Node nodeExtension){
            _visitables.remove(this.extension);
            if (nodeExtension!=null){ this.extension= new NodeBuilder(nodeExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.NodeExtensionNested withNewNodeExtension(){
            return new NodeExtensionNestedImpl();
    }

    public NamedExtensionFluent.NodeExtensionNested withNewNodeExtensionLike(Node item){
            return new NodeExtensionNestedImpl(item);
    }

    public A withReplicaSetExtension(ReplicaSet replicaSetExtension){
            _visitables.remove(this.extension);
            if (replicaSetExtension!=null){ this.extension= new ReplicaSetBuilder(replicaSetExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ReplicaSetExtensionNested withNewReplicaSetExtension(){
            return new ReplicaSetExtensionNestedImpl();
    }

    public NamedExtensionFluent.ReplicaSetExtensionNested withNewReplicaSetExtensionLike(ReplicaSet item){
            return new ReplicaSetExtensionNestedImpl(item);
    }

    public A withClusterPipelineTemplateExtension(ClusterPipelineTemplate clusterPipelineTemplateExtension){
            _visitables.remove(this.extension);
            if (clusterPipelineTemplateExtension!=null){ this.extension= new ClusterPipelineTemplateBuilder(clusterPipelineTemplateExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ClusterPipelineTemplateExtensionNested withNewClusterPipelineTemplateExtension(){
            return new ClusterPipelineTemplateExtensionNestedImpl();
    }

    public NamedExtensionFluent.ClusterPipelineTemplateExtensionNested withNewClusterPipelineTemplateExtensionLike(ClusterPipelineTemplate item){
            return new ClusterPipelineTemplateExtensionNestedImpl(item);
    }

    public A withJobExtension(Job jobExtension){
            _visitables.remove(this.extension);
            if (jobExtension!=null){ this.extension= new JobBuilder(jobExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.JobExtensionNested withNewJobExtension(){
            return new JobExtensionNestedImpl();
    }

    public NamedExtensionFluent.JobExtensionNested withNewJobExtensionLike(Job item){
            return new JobExtensionNestedImpl(item);
    }

    public A withClusterPipelineTaskTemplateExtension(ClusterPipelineTaskTemplate clusterPipelineTaskTemplateExtension){
            _visitables.remove(this.extension);
            if (clusterPipelineTaskTemplateExtension!=null){ this.extension= new ClusterPipelineTaskTemplateBuilder(clusterPipelineTaskTemplateExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ClusterPipelineTaskTemplateExtensionNested withNewClusterPipelineTaskTemplateExtension(){
            return new ClusterPipelineTaskTemplateExtensionNestedImpl();
    }

    public NamedExtensionFluent.ClusterPipelineTaskTemplateExtensionNested withNewClusterPipelineTaskTemplateExtensionLike(ClusterPipelineTaskTemplate item){
            return new ClusterPipelineTaskTemplateExtensionNestedImpl(item);
    }

    public A withDeploymentExtension(Deployment deploymentExtension){
            _visitables.remove(this.extension);
            if (deploymentExtension!=null){ this.extension= new DeploymentBuilder(deploymentExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.DeploymentExtensionNested withNewDeploymentExtension(){
            return new DeploymentExtensionNestedImpl();
    }

    public NamedExtensionFluent.DeploymentExtensionNested withNewDeploymentExtensionLike(Deployment item){
            return new DeploymentExtensionNestedImpl(item);
    }

    public A withJenkinsExtension(Jenkins jenkinsExtension){
            _visitables.remove(this.extension);
            if (jenkinsExtension!=null){ this.extension= new JenkinsBuilder(jenkinsExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.JenkinsExtensionNested withNewJenkinsExtension(){
            return new JenkinsExtensionNestedImpl();
    }

    public NamedExtensionFluent.JenkinsExtensionNested withNewJenkinsExtensionLike(Jenkins item){
            return new JenkinsExtensionNestedImpl(item);
    }

    public A withDaemonSetExtension(DaemonSet daemonSetExtension){
            _visitables.remove(this.extension);
            if (daemonSetExtension!=null){ this.extension= new DaemonSetBuilder(daemonSetExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.DaemonSetExtensionNested withNewDaemonSetExtension(){
            return new DaemonSetExtensionNestedImpl();
    }

    public NamedExtensionFluent.DaemonSetExtensionNested withNewDaemonSetExtensionLike(DaemonSet item){
            return new DaemonSetExtensionNestedImpl(item);
    }

    public A withPodDisruptionBudgetExtension(PodDisruptionBudget podDisruptionBudgetExtension){
            _visitables.remove(this.extension);
            if (podDisruptionBudgetExtension!=null){ this.extension= new PodDisruptionBudgetBuilder(podDisruptionBudgetExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PodDisruptionBudgetExtensionNested withNewPodDisruptionBudgetExtension(){
            return new PodDisruptionBudgetExtensionNestedImpl();
    }

    public NamedExtensionFluent.PodDisruptionBudgetExtensionNested withNewPodDisruptionBudgetExtensionLike(PodDisruptionBudget item){
            return new PodDisruptionBudgetExtensionNestedImpl(item);
    }

    public A withProjectExtension(Project projectExtension){
            _visitables.remove(this.extension);
            if (projectExtension!=null){ this.extension= new ProjectBuilder(projectExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.ProjectExtensionNested withNewProjectExtension(){
            return new ProjectExtensionNestedImpl();
    }

    public NamedExtensionFluent.ProjectExtensionNested withNewProjectExtensionLike(Project item){
            return new ProjectExtensionNestedImpl(item);
    }

    public A withPersistentVolumeExtension(PersistentVolume persistentVolumeExtension){
            _visitables.remove(this.extension);
            if (persistentVolumeExtension!=null){ this.extension= new PersistentVolumeBuilder(persistentVolumeExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.PersistentVolumeExtensionNested withNewPersistentVolumeExtension(){
            return new PersistentVolumeExtensionNestedImpl();
    }

    public NamedExtensionFluent.PersistentVolumeExtensionNested withNewPersistentVolumeExtensionLike(PersistentVolume item){
            return new PersistentVolumeExtensionNestedImpl(item);
    }

    public A withCodeRepositoryExtension(CodeRepository codeRepositoryExtension){
            _visitables.remove(this.extension);
            if (codeRepositoryExtension!=null){ this.extension= new CodeRepositoryBuilder(codeRepositoryExtension); _visitables.add(this.extension);} return (A) this;
    }

    public NamedExtensionFluent.CodeRepositoryExtensionNested withNewCodeRepositoryExtension(){
            return new CodeRepositoryExtensionNestedImpl();
    }

    public NamedExtensionFluent.CodeRepositoryExtensionNested withNewCodeRepositoryExtensionLike(CodeRepository item){
            return new CodeRepositoryExtensionNestedImpl(item);
    }

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

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

    public Boolean hasName(){
            return this.name!=null;
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            NamedExtensionFluentImpl that = (NamedExtensionFluentImpl) o;
            if (extension != null ? !extension.equals(that.extension) :that.extension != null) return false;
            if (name != null ? !name.equals(that.name) :that.name != null) return false;
            return true;
    }


    public class BindingExtensionNestedImpl extends BindingFluentImpl> implements NamedExtensionFluent.BindingExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final BindingBuilder builder;
    
            BindingExtensionNestedImpl(Binding item){
                    this.builder = new BindingBuilder(this, item);
            }
            BindingExtensionNestedImpl(){
                    this.builder = new BindingBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withBindingExtension(builder.build());
    }
    public N endBindingExtension(){
            return and();
    }

}
    public class IngressExtensionNestedImpl extends IngressFluentImpl> implements NamedExtensionFluent.IngressExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressBuilder builder;
    
            IngressExtensionNestedImpl(Ingress item){
                    this.builder = new IngressBuilder(this, item);
            }
            IngressExtensionNestedImpl(){
                    this.builder = new IngressBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withIngressExtension(builder.build());
    }
    public N endIngressExtension(){
            return and();
    }

}
    public class LocalSubjectAccessReviewExtensionNestedImpl extends LocalSubjectAccessReviewFluentImpl> implements NamedExtensionFluent.LocalSubjectAccessReviewExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final LocalSubjectAccessReviewBuilder builder;
    
            LocalSubjectAccessReviewExtensionNestedImpl(LocalSubjectAccessReview item){
                    this.builder = new LocalSubjectAccessReviewBuilder(this, item);
            }
            LocalSubjectAccessReviewExtensionNestedImpl(){
                    this.builder = new LocalSubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withLocalSubjectAccessReviewExtension(builder.build());
    }
    public N endLocalSubjectAccessReviewExtension(){
            return and();
    }

}
    public class StatefulSetExtensionNestedImpl extends StatefulSetFluentImpl> implements NamedExtensionFluent.StatefulSetExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetBuilder builder;
    
            StatefulSetExtensionNestedImpl(StatefulSet item){
                    this.builder = new StatefulSetBuilder(this, item);
            }
            StatefulSetExtensionNestedImpl(){
                    this.builder = new StatefulSetBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withStatefulSetExtension(builder.build());
    }
    public N endStatefulSetExtension(){
            return and();
    }

}
    public class PipelineTemplateTaskInstanceExtensionNestedImpl extends PipelineTemplateTaskInstanceFluentImpl> implements NamedExtensionFluent.PipelineTemplateTaskInstanceExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateTaskInstanceBuilder builder;
    
            PipelineTemplateTaskInstanceExtensionNestedImpl(PipelineTemplateTaskInstance item){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this, item);
            }
            PipelineTemplateTaskInstanceExtensionNestedImpl(){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPipelineTemplateTaskInstanceExtension(builder.build());
    }
    public N endPipelineTemplateTaskInstanceExtension(){
            return and();
    }

}
    public class PodSecurityPolicyExtensionNestedImpl extends PodSecurityPolicyFluentImpl> implements NamedExtensionFluent.PodSecurityPolicyExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyBuilder builder;
    
            PodSecurityPolicyExtensionNestedImpl(PodSecurityPolicy item){
                    this.builder = new PodSecurityPolicyBuilder(this, item);
            }
            PodSecurityPolicyExtensionNestedImpl(){
                    this.builder = new PodSecurityPolicyBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPodSecurityPolicyExtension(builder.build());
    }
    public N endPodSecurityPolicyExtension(){
            return and();
    }

}
    public class PipelineExtensionNestedImpl extends PipelineFluentImpl> implements NamedExtensionFluent.PipelineExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineBuilder builder;
    
            PipelineExtensionNestedImpl(Pipeline item){
                    this.builder = new PipelineBuilder(this, item);
            }
            PipelineExtensionNestedImpl(){
                    this.builder = new PipelineBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPipelineExtension(builder.build());
    }
    public N endPipelineExtension(){
            return and();
    }

}
    public class ResourceQuotaExtensionNestedImpl extends ResourceQuotaFluentImpl> implements NamedExtensionFluent.ResourceQuotaExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaBuilder builder;
    
            ResourceQuotaExtensionNestedImpl(ResourceQuota item){
                    this.builder = new ResourceQuotaBuilder(this, item);
            }
            ResourceQuotaExtensionNestedImpl(){
                    this.builder = new ResourceQuotaBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withResourceQuotaExtension(builder.build());
    }
    public N endResourceQuotaExtension(){
            return and();
    }

}
    public class ServiceAccountExtensionNestedImpl extends ServiceAccountFluentImpl> implements NamedExtensionFluent.ServiceAccountExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountBuilder builder;
    
            ServiceAccountExtensionNestedImpl(ServiceAccount item){
                    this.builder = new ServiceAccountBuilder(this, item);
            }
            ServiceAccountExtensionNestedImpl(){
                    this.builder = new ServiceAccountBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withServiceAccountExtension(builder.build());
    }
    public N endServiceAccountExtension(){
            return and();
    }

}
    public class ConfigMapExtensionNestedImpl extends ConfigMapFluentImpl> implements NamedExtensionFluent.ConfigMapExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapBuilder builder;
    
            ConfigMapExtensionNestedImpl(ConfigMap item){
                    this.builder = new ConfigMapBuilder(this, item);
            }
            ConfigMapExtensionNestedImpl(){
                    this.builder = new ConfigMapBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withConfigMapExtension(builder.build());
    }
    public N endConfigMapExtension(){
            return and();
    }

}
    public class JenkinsBindingExtensionNestedImpl extends JenkinsBindingFluentImpl> implements NamedExtensionFluent.JenkinsBindingExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingBuilder builder;
    
            JenkinsBindingExtensionNestedImpl(JenkinsBinding item){
                    this.builder = new JenkinsBindingBuilder(this, item);
            }
            JenkinsBindingExtensionNestedImpl(){
                    this.builder = new JenkinsBindingBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withJenkinsBindingExtension(builder.build());
    }
    public N endJenkinsBindingExtension(){
            return and();
    }

}
    public class PipelineTemplateExtensionNestedImpl extends PipelineTemplateFluentImpl> implements NamedExtensionFluent.PipelineTemplateExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateBuilder builder;
    
            PipelineTemplateExtensionNestedImpl(PipelineTemplate item){
                    this.builder = new PipelineTemplateBuilder(this, item);
            }
            PipelineTemplateExtensionNestedImpl(){
                    this.builder = new PipelineTemplateBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPipelineTemplateExtension(builder.build());
    }
    public N endPipelineTemplateExtension(){
            return and();
    }

}
    public class CronJobExtensionNestedImpl extends CronJobFluentImpl> implements NamedExtensionFluent.CronJobExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobBuilder builder;
    
            CronJobExtensionNestedImpl(CronJob item){
                    this.builder = new CronJobBuilder(this, item);
            }
            CronJobExtensionNestedImpl(){
                    this.builder = new CronJobBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withCronJobExtension(builder.build());
    }
    public N endCronJobExtension(){
            return and();
    }

}
    public class SubjectAccessReviewExtensionNestedImpl extends SubjectAccessReviewFluentImpl> implements NamedExtensionFluent.SubjectAccessReviewExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final SubjectAccessReviewBuilder builder;
    
            SubjectAccessReviewExtensionNestedImpl(SubjectAccessReview item){
                    this.builder = new SubjectAccessReviewBuilder(this, item);
            }
            SubjectAccessReviewExtensionNestedImpl(){
                    this.builder = new SubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withSubjectAccessReviewExtension(builder.build());
    }
    public N endSubjectAccessReviewExtension(){
            return and();
    }

}
    public class PodTemplateExtensionNestedImpl extends PodTemplateFluentImpl> implements NamedExtensionFluent.PodTemplateExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateBuilder builder;
    
            PodTemplateExtensionNestedImpl(PodTemplate item){
                    this.builder = new PodTemplateBuilder(this, item);
            }
            PodTemplateExtensionNestedImpl(){
                    this.builder = new PodTemplateBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPodTemplateExtension(builder.build());
    }
    public N endPodTemplateExtension(){
            return and();
    }

}
    public class TokenReviewExtensionNestedImpl extends TokenReviewFluentImpl> implements NamedExtensionFluent.TokenReviewExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewBuilder builder;
    
            TokenReviewExtensionNestedImpl(TokenReview item){
                    this.builder = new TokenReviewBuilder(this, item);
            }
            TokenReviewExtensionNestedImpl(){
                    this.builder = new TokenReviewBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withTokenReviewExtension(builder.build());
    }
    public N endTokenReviewExtension(){
            return and();
    }

}
    public class CustomResourceDefinitionExtensionNestedImpl extends CustomResourceDefinitionFluentImpl> implements NamedExtensionFluent.CustomResourceDefinitionExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionBuilder builder;
    
            CustomResourceDefinitionExtensionNestedImpl(CustomResourceDefinition item){
                    this.builder = new CustomResourceDefinitionBuilder(this, item);
            }
            CustomResourceDefinitionExtensionNestedImpl(){
                    this.builder = new CustomResourceDefinitionBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withCustomResourceDefinitionExtension(builder.build());
    }
    public N endCustomResourceDefinitionExtension(){
            return and();
    }

}
    public class StorageClassExtensionNestedImpl extends StorageClassFluentImpl> implements NamedExtensionFluent.StorageClassExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassBuilder builder;
    
            StorageClassExtensionNestedImpl(StorageClass item){
                    this.builder = new StorageClassBuilder(this, item);
            }
            StorageClassExtensionNestedImpl(){
                    this.builder = new StorageClassBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withStorageClassExtension(builder.build());
    }
    public N endStorageClassExtension(){
            return and();
    }

}
    public class PipelineConfigTemplateExtensionNestedImpl extends PipelineConfigTemplateFluentImpl> implements NamedExtensionFluent.PipelineConfigTemplateExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigTemplateBuilder builder;
    
            PipelineConfigTemplateExtensionNestedImpl(PipelineConfigTemplate item){
                    this.builder = new PipelineConfigTemplateBuilder(this, item);
            }
            PipelineConfigTemplateExtensionNestedImpl(){
                    this.builder = new PipelineConfigTemplateBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPipelineConfigTemplateExtension(builder.build());
    }
    public N endPipelineConfigTemplateExtension(){
            return and();
    }

}
    public class NamespaceExtensionNestedImpl extends NamespaceFluentImpl> implements NamedExtensionFluent.NamespaceExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceBuilder builder;
    
            NamespaceExtensionNestedImpl(Namespace item){
                    this.builder = new NamespaceBuilder(this, item);
            }
            NamespaceExtensionNestedImpl(){
                    this.builder = new NamespaceBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withNamespaceExtension(builder.build());
    }
    public N endNamespaceExtension(){
            return and();
    }

}
    public class PipelineConfigExtensionNestedImpl extends PipelineConfigFluentImpl> implements NamedExtensionFluent.PipelineConfigExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigBuilder builder;
    
            PipelineConfigExtensionNestedImpl(PipelineConfig item){
                    this.builder = new PipelineConfigBuilder(this, item);
            }
            PipelineConfigExtensionNestedImpl(){
                    this.builder = new PipelineConfigBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPipelineConfigExtension(builder.build());
    }
    public N endPipelineConfigExtension(){
            return and();
    }

}
    public class CodeRepoServiceExtensionNestedImpl extends CodeRepoServiceFluentImpl> implements NamedExtensionFluent.CodeRepoServiceExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoServiceBuilder builder;
    
            CodeRepoServiceExtensionNestedImpl(CodeRepoService item){
                    this.builder = new CodeRepoServiceBuilder(this, item);
            }
            CodeRepoServiceExtensionNestedImpl(){
                    this.builder = new CodeRepoServiceBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withCodeRepoServiceExtension(builder.build());
    }
    public N endCodeRepoServiceExtension(){
            return and();
    }

}
    public class CodeRepoBindingExtensionNestedImpl extends CodeRepoBindingFluentImpl> implements NamedExtensionFluent.CodeRepoBindingExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoBindingBuilder builder;
    
            CodeRepoBindingExtensionNestedImpl(CodeRepoBinding item){
                    this.builder = new CodeRepoBindingBuilder(this, item);
            }
            CodeRepoBindingExtensionNestedImpl(){
                    this.builder = new CodeRepoBindingBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withCodeRepoBindingExtension(builder.build());
    }
    public N endCodeRepoBindingExtension(){
            return and();
    }

}
    public class ScaleExtensionNestedImpl extends ScaleFluentImpl> implements NamedExtensionFluent.ScaleExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleBuilder builder;
    
            ScaleExtensionNestedImpl(Scale item){
                    this.builder = new ScaleBuilder(this, item);
            }
            ScaleExtensionNestedImpl(){
                    this.builder = new ScaleBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withScaleExtension(builder.build());
    }
    public N endScaleExtension(){
            return and();
    }

}
    public class PipelineTaskTemplateExtensionNestedImpl extends PipelineTaskTemplateFluentImpl> implements NamedExtensionFluent.PipelineTaskTemplateExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskTemplateBuilder builder;
    
            PipelineTaskTemplateExtensionNestedImpl(PipelineTaskTemplate item){
                    this.builder = new PipelineTaskTemplateBuilder(this, item);
            }
            PipelineTaskTemplateExtensionNestedImpl(){
                    this.builder = new PipelineTaskTemplateBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPipelineTaskTemplateExtension(builder.build());
    }
    public N endPipelineTaskTemplateExtension(){
            return and();
    }

}
    public class PodExtensionNestedImpl extends PodFluentImpl> implements NamedExtensionFluent.PodExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodBuilder builder;
    
            PodExtensionNestedImpl(Pod item){
                    this.builder = new PodBuilder(this, item);
            }
            PodExtensionNestedImpl(){
                    this.builder = new PodBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPodExtension(builder.build());
    }
    public N endPodExtension(){
            return and();
    }

}
    public class HorizontalPodAutoscalerExtensionNestedImpl extends HorizontalPodAutoscalerFluentImpl> implements NamedExtensionFluent.HorizontalPodAutoscalerExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerBuilder builder;
    
            HorizontalPodAutoscalerExtensionNestedImpl(HorizontalPodAutoscaler item){
                    this.builder = new HorizontalPodAutoscalerBuilder(this, item);
            }
            HorizontalPodAutoscalerExtensionNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withHorizontalPodAutoscalerExtension(builder.build());
    }
    public N endHorizontalPodAutoscalerExtension(){
            return and();
    }

}
    public class ThirdPartyResourceExtensionNestedImpl extends ThirdPartyResourceFluentImpl> implements NamedExtensionFluent.ThirdPartyResourceExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceBuilder builder;
    
            ThirdPartyResourceExtensionNestedImpl(ThirdPartyResource item){
                    this.builder = new ThirdPartyResourceBuilder(this, item);
            }
            ThirdPartyResourceExtensionNestedImpl(){
                    this.builder = new ThirdPartyResourceBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withThirdPartyResourceExtension(builder.build());
    }
    public N endThirdPartyResourceExtension(){
            return and();
    }

}
    public class ComponentStatusExtensionNestedImpl extends ComponentStatusFluentImpl> implements NamedExtensionFluent.ComponentStatusExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentStatusBuilder builder;
    
            ComponentStatusExtensionNestedImpl(ComponentStatus item){
                    this.builder = new ComponentStatusBuilder(this, item);
            }
            ComponentStatusExtensionNestedImpl(){
                    this.builder = new ComponentStatusBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withComponentStatusExtension(builder.build());
    }
    public N endComponentStatusExtension(){
            return and();
    }

}
    public class PersistentVolumeClaimExtensionNestedImpl extends PersistentVolumeClaimFluentImpl> implements NamedExtensionFluent.PersistentVolumeClaimExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimBuilder builder;
    
            PersistentVolumeClaimExtensionNestedImpl(PersistentVolumeClaim item){
                    this.builder = new PersistentVolumeClaimBuilder(this, item);
            }
            PersistentVolumeClaimExtensionNestedImpl(){
                    this.builder = new PersistentVolumeClaimBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPersistentVolumeClaimExtension(builder.build());
    }
    public N endPersistentVolumeClaimExtension(){
            return and();
    }

}
    public class SecretExtensionNestedImpl extends SecretFluentImpl> implements NamedExtensionFluent.SecretExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretBuilder builder;
    
            SecretExtensionNestedImpl(Secret item){
                    this.builder = new SecretBuilder(this, item);
            }
            SecretExtensionNestedImpl(){
                    this.builder = new SecretBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withSecretExtension(builder.build());
    }
    public N endSecretExtension(){
            return and();
    }

}
    public class ReplicationControllerExtensionNestedImpl extends ReplicationControllerFluentImpl> implements NamedExtensionFluent.ReplicationControllerExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerBuilder builder;
    
            ReplicationControllerExtensionNestedImpl(ReplicationController item){
                    this.builder = new ReplicationControllerBuilder(this, item);
            }
            ReplicationControllerExtensionNestedImpl(){
                    this.builder = new ReplicationControllerBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withReplicationControllerExtension(builder.build());
    }
    public N endReplicationControllerExtension(){
            return and();
    }

}
    public class EndpointsExtensionNestedImpl extends EndpointsFluentImpl> implements NamedExtensionFluent.EndpointsExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsBuilder builder;
    
            EndpointsExtensionNestedImpl(Endpoints item){
                    this.builder = new EndpointsBuilder(this, item);
            }
            EndpointsExtensionNestedImpl(){
                    this.builder = new EndpointsBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withEndpointsExtension(builder.build());
    }
    public N endEndpointsExtension(){
            return and();
    }

}
    public class LimitRangeExtensionNestedImpl extends LimitRangeFluentImpl> implements NamedExtensionFluent.LimitRangeExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeBuilder builder;
    
            LimitRangeExtensionNestedImpl(LimitRange item){
                    this.builder = new LimitRangeBuilder(this, item);
            }
            LimitRangeExtensionNestedImpl(){
                    this.builder = new LimitRangeBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withLimitRangeExtension(builder.build());
    }
    public N endLimitRangeExtension(){
            return and();
    }

}
    public class NetworkPolicyExtensionNestedImpl extends NetworkPolicyFluentImpl> implements NamedExtensionFluent.NetworkPolicyExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyBuilder builder;
    
            NetworkPolicyExtensionNestedImpl(NetworkPolicy item){
                    this.builder = new NetworkPolicyBuilder(this, item);
            }
            NetworkPolicyExtensionNestedImpl(){
                    this.builder = new NetworkPolicyBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withNetworkPolicyExtension(builder.build());
    }
    public N endNetworkPolicyExtension(){
            return and();
    }

}
    public class ServiceExtensionNestedImpl extends ServiceFluentImpl> implements NamedExtensionFluent.ServiceExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceBuilder builder;
    
            ServiceExtensionNestedImpl(Service item){
                    this.builder = new ServiceBuilder(this, item);
            }
            ServiceExtensionNestedImpl(){
                    this.builder = new ServiceBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withServiceExtension(builder.build());
    }
    public N endServiceExtension(){
            return and();
    }

}
    public class EventExtensionNestedImpl extends EventFluentImpl> implements NamedExtensionFluent.EventExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventBuilder builder;
    
            EventExtensionNestedImpl(Event item){
                    this.builder = new EventBuilder(this, item);
            }
            EventExtensionNestedImpl(){
                    this.builder = new EventBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withEventExtension(builder.build());
    }
    public N endEventExtension(){
            return and();
    }

}
    public class NodeExtensionNestedImpl extends NodeFluentImpl> implements NamedExtensionFluent.NodeExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeBuilder builder;
    
            NodeExtensionNestedImpl(Node item){
                    this.builder = new NodeBuilder(this, item);
            }
            NodeExtensionNestedImpl(){
                    this.builder = new NodeBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withNodeExtension(builder.build());
    }
    public N endNodeExtension(){
            return and();
    }

}
    public class ReplicaSetExtensionNestedImpl extends ReplicaSetFluentImpl> implements NamedExtensionFluent.ReplicaSetExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetBuilder builder;
    
            ReplicaSetExtensionNestedImpl(ReplicaSet item){
                    this.builder = new ReplicaSetBuilder(this, item);
            }
            ReplicaSetExtensionNestedImpl(){
                    this.builder = new ReplicaSetBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withReplicaSetExtension(builder.build());
    }
    public N endReplicaSetExtension(){
            return and();
    }

}
    public class ClusterPipelineTemplateExtensionNestedImpl extends ClusterPipelineTemplateFluentImpl> implements NamedExtensionFluent.ClusterPipelineTemplateExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPipelineTemplateBuilder builder;
    
            ClusterPipelineTemplateExtensionNestedImpl(ClusterPipelineTemplate item){
                    this.builder = new ClusterPipelineTemplateBuilder(this, item);
            }
            ClusterPipelineTemplateExtensionNestedImpl(){
                    this.builder = new ClusterPipelineTemplateBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withClusterPipelineTemplateExtension(builder.build());
    }
    public N endClusterPipelineTemplateExtension(){
            return and();
    }

}
    public class JobExtensionNestedImpl extends JobFluentImpl> implements NamedExtensionFluent.JobExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobBuilder builder;
    
            JobExtensionNestedImpl(Job item){
                    this.builder = new JobBuilder(this, item);
            }
            JobExtensionNestedImpl(){
                    this.builder = new JobBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withJobExtension(builder.build());
    }
    public N endJobExtension(){
            return and();
    }

}
    public class ClusterPipelineTaskTemplateExtensionNestedImpl extends ClusterPipelineTaskTemplateFluentImpl> implements NamedExtensionFluent.ClusterPipelineTaskTemplateExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPipelineTaskTemplateBuilder builder;
    
            ClusterPipelineTaskTemplateExtensionNestedImpl(ClusterPipelineTaskTemplate item){
                    this.builder = new ClusterPipelineTaskTemplateBuilder(this, item);
            }
            ClusterPipelineTaskTemplateExtensionNestedImpl(){
                    this.builder = new ClusterPipelineTaskTemplateBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withClusterPipelineTaskTemplateExtension(builder.build());
    }
    public N endClusterPipelineTaskTemplateExtension(){
            return and();
    }

}
    public class DeploymentExtensionNestedImpl extends DeploymentFluentImpl> implements NamedExtensionFluent.DeploymentExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentBuilder builder;
    
            DeploymentExtensionNestedImpl(Deployment item){
                    this.builder = new DeploymentBuilder(this, item);
            }
            DeploymentExtensionNestedImpl(){
                    this.builder = new DeploymentBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withDeploymentExtension(builder.build());
    }
    public N endDeploymentExtension(){
            return and();
    }

}
    public class JenkinsExtensionNestedImpl extends JenkinsFluentImpl> implements NamedExtensionFluent.JenkinsExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBuilder builder;
    
            JenkinsExtensionNestedImpl(Jenkins item){
                    this.builder = new JenkinsBuilder(this, item);
            }
            JenkinsExtensionNestedImpl(){
                    this.builder = new JenkinsBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withJenkinsExtension(builder.build());
    }
    public N endJenkinsExtension(){
            return and();
    }

}
    public class DaemonSetExtensionNestedImpl extends DaemonSetFluentImpl> implements NamedExtensionFluent.DaemonSetExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetBuilder builder;
    
            DaemonSetExtensionNestedImpl(DaemonSet item){
                    this.builder = new DaemonSetBuilder(this, item);
            }
            DaemonSetExtensionNestedImpl(){
                    this.builder = new DaemonSetBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withDaemonSetExtension(builder.build());
    }
    public N endDaemonSetExtension(){
            return and();
    }

}
    public class PodDisruptionBudgetExtensionNestedImpl extends PodDisruptionBudgetFluentImpl> implements NamedExtensionFluent.PodDisruptionBudgetExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetBuilder builder;
    
            PodDisruptionBudgetExtensionNestedImpl(PodDisruptionBudget item){
                    this.builder = new PodDisruptionBudgetBuilder(this, item);
            }
            PodDisruptionBudgetExtensionNestedImpl(){
                    this.builder = new PodDisruptionBudgetBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPodDisruptionBudgetExtension(builder.build());
    }
    public N endPodDisruptionBudgetExtension(){
            return and();
    }

}
    public class ProjectExtensionNestedImpl extends ProjectFluentImpl> implements NamedExtensionFluent.ProjectExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectBuilder builder;
    
            ProjectExtensionNestedImpl(Project item){
                    this.builder = new ProjectBuilder(this, item);
            }
            ProjectExtensionNestedImpl(){
                    this.builder = new ProjectBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withProjectExtension(builder.build());
    }
    public N endProjectExtension(){
            return and();
    }

}
    public class PersistentVolumeExtensionNestedImpl extends PersistentVolumeFluentImpl> implements NamedExtensionFluent.PersistentVolumeExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeBuilder builder;
    
            PersistentVolumeExtensionNestedImpl(PersistentVolume item){
                    this.builder = new PersistentVolumeBuilder(this, item);
            }
            PersistentVolumeExtensionNestedImpl(){
                    this.builder = new PersistentVolumeBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withPersistentVolumeExtension(builder.build());
    }
    public N endPersistentVolumeExtension(){
            return and();
    }

}
    public class CodeRepositoryExtensionNestedImpl extends CodeRepositoryFluentImpl> implements NamedExtensionFluent.CodeRepositoryExtensionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryBuilder builder;
    
            CodeRepositoryExtensionNestedImpl(CodeRepository item){
                    this.builder = new CodeRepositoryBuilder(this, item);
            }
            CodeRepositoryExtensionNestedImpl(){
                    this.builder = new CodeRepositoryBuilder(this);
            }
    
    public N and(){
            return (N) NamedExtensionFluentImpl.this.withCodeRepositoryExtension(builder.build());
    }
    public N endCodeRepositoryExtension(){
            return and();
    }

}


}
Related Artifacts