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

annotations.io.alauda.devops.api.model.SubjectAccessReviewFluentImpl Maven / Gradle / Ivy

There is a newer version: 0.2.12
Show newest version
package io.alauda.devops.api.model;

import io.alauda.kubernetes.api.model.Node;
import com.fasterxml.jackson.annotation.JsonInclude;
import java.util.ArrayList;
import java.lang.String;
import io.alauda.kubernetes.api.model.NodeBuilder;
import io.alauda.kubernetes.api.model.SecretBuilder;
import io.alauda.kubernetes.api.model.ReplicationController;
import io.alauda.kubernetes.api.model.PipelineTemplateTaskInstanceFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionFluentImpl;
import io.alauda.kubernetes.api.model.PodTemplateFluentImpl;
import io.alauda.kubernetes.api.model.HasMetadata;
import io.alauda.kubernetes.api.model.Pod;
import io.alauda.kubernetes.api.model.PodBuilder;
import io.alauda.kubernetes.api.model.PipelineConfigTemplate;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyBuilder;
import io.alauda.kubernetes.api.model.Project;
import io.alauda.kubernetes.api.model.ReplicationControllerFluentImpl;
import io.alauda.kubernetes.api.model.JenkinsBuilder;
import io.alauda.kubernetes.api.model.StorageClassBuilder;
import io.alauda.kubernetes.api.model.EndpointsBuilder;
import io.alauda.kubernetes.api.model.NamespaceBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetBuilder;
import io.alauda.kubernetes.api.model.JenkinsBindingBuilder;
import java.lang.Deprecated;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicy;
import io.alauda.kubernetes.api.model.PodFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSet;
import io.alauda.kubernetes.api.model.StorageClass;
import io.alauda.kubernetes.api.model.PipelineConfigTemplateBuilder;
import io.alauda.kubernetes.api.model.EventBuilder;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder;
import io.alauda.kubernetes.api.model.ConfigMapFluentImpl;
import io.alauda.kubernetes.api.model.Event;
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.PodTemplateBuilder;
import io.alauda.kubernetes.api.model.extensions.Deployment;
import io.alauda.kubernetes.api.model.PipelineTemplateTaskInstanceBuilder;
import io.alauda.kubernetes.api.builder.Predicate;
import java.util.List;
import io.alauda.kubernetes.api.model.PodTemplate;
import io.alauda.kubernetes.api.model.Binding;
import io.alauda.kubernetes.api.model.LimitRangeBuilder;
import io.alauda.kubernetes.api.model.PersistentVolumeClaimBuilder;
import io.alauda.kubernetes.api.model.PersistentVolumeClaimFluentImpl;
import io.alauda.kubernetes.api.model.PipelineConfigTemplateFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceFluentImpl;
import io.alauda.kubernetes.api.model.ProjectBuilder;
import io.alauda.kubernetes.api.model.JobFluentImpl;
import io.alauda.kubernetes.api.model.PersistentVolumeClaim;
import io.alauda.kubernetes.api.model.extensions.DaemonSet;
import io.alauda.kubernetes.api.model.ProjectFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetFluentImpl;
import javax.validation.constraints.NotNull;
import io.alauda.kubernetes.api.model.PipelineFluentImpl;
import io.alauda.kubernetes.api.model.SecretFluentImpl;
import io.alauda.kubernetes.api.model.StorageClassFluentImpl;
import io.alauda.kubernetes.api.model.PipelineConfig;
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.model.PipelineConfigFluentImpl;
import io.alauda.kubernetes.api.model.EndpointsFluentImpl;
import io.alauda.kubernetes.api.model.ServiceAccountFluentImpl;
import io.alauda.kubernetes.api.builder.BaseFluent;
import io.alauda.kubernetes.api.model.HorizontalPodAutoscalerFluentImpl;
import java.lang.Boolean;
import io.alauda.kubernetes.api.model.JenkinsBinding;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicy;
import io.alauda.kubernetes.api.model.JobBuilder;
import io.alauda.kubernetes.api.model.PipelineTemplateTaskInstance;
import io.alauda.kubernetes.api.model.BindingFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetFluentImpl;
import io.alauda.kubernetes.api.model.Namespace;
import javax.validation.Valid;
import io.alauda.kubernetes.api.model.CronJob;
import io.alauda.kubernetes.api.model.ComponentStatus;
import java.lang.Object;
import io.alauda.kubernetes.api.model.extensions.DeploymentBuilder;
import io.alauda.kubernetes.api.model.ServiceAccount;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResource;
import io.alauda.kubernetes.api.model.ComponentStatusFluentImpl;
import io.alauda.kubernetes.api.model.LimitRangeFluentImpl;
import io.alauda.kubernetes.api.model.authentication.TokenReviewBuilder;
import io.alauda.kubernetes.api.model.PipelineConfigBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReview;
import io.alauda.kubernetes.api.model.Pipeline;
import io.alauda.kubernetes.api.model.PersistentVolume;
import io.alauda.kubernetes.api.model.PersistentVolumeBuilder;
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.EventFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetBuilder;
import io.alauda.kubernetes.api.model.ConfigMapBuilder;
import io.alauda.kubernetes.api.model.Job;
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.ReplicationControllerBuilder;
import io.alauda.kubernetes.api.model.ResourceQuotaBuilder;
import io.alauda.kubernetes.api.model.ServiceAccountBuilder;
import io.alauda.kubernetes.api.model.extensions.Ingress;
import io.alauda.kubernetes.api.model.CronJobBuilder;
import io.alauda.kubernetes.api.model.ResourceQuotaFluentImpl;
import io.alauda.kubernetes.api.model.Jenkins;
import io.alauda.kubernetes.api.model.Secret;
import io.alauda.kubernetes.api.model.LimitRange;
import io.alauda.kubernetes.api.model.HorizontalPodAutoscaler;
import java.util.Collection;
import io.alauda.kubernetes.api.model.extensions.StatefulSet;
import io.alauda.kubernetes.api.model.PipelineBuilder;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudget;
import io.alauda.kubernetes.api.model.BindingBuilder;
import io.alauda.kubernetes.api.model.ComponentStatusBuilder;
import io.alauda.kubernetes.api.builder.Nested;
import io.alauda.kubernetes.api.model.HorizontalPodAutoscalerBuilder;
import io.alauda.kubernetes.api.model.JenkinsFluentImpl;
import io.alauda.kubernetes.api.model.ServiceBuilder;
import io.alauda.kubernetes.api.model.Endpoints;
import io.alauda.kubernetes.api.model.extensions.DaemonSetBuilder;
import io.alauda.kubernetes.api.model.CronJobFluentImpl;
import io.alauda.kubernetes.api.model.ResourceQuota;
import io.alauda.kubernetes.api.model.JenkinsBindingFluentImpl;
import io.alauda.kubernetes.api.model.NamespaceFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetFluentImpl;
import io.alauda.kubernetes.api.model.ConfigMap;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinition;
import io.alauda.kubernetes.api.model.Service;
import io.alauda.kubernetes.api.model.extensions.Scale;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyBuilder;
import io.alauda.kubernetes.api.model.NodeFluentImpl;
import io.alauda.kubernetes.api.model.PersistentVolumeFluentImpl;
import io.alauda.kubernetes.api.model.ServiceFluentImpl;

public class SubjectAccessReviewFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements SubjectAccessReviewFluent{

    private String apiVersion;
    private VisitableBuilder content;
    private List groups = new ArrayList();
    private Boolean isNonResourceURL;
    private String kind;
    private String namespace;
    private String path;
    private String resource;
    private String resourceAPIGroup;
    private String resourceAPIVersion;
    private String resourceName;
    private List scopes = new ArrayList();
    private String user;
    private String verb;

    public SubjectAccessReviewFluentImpl(){
    }
    public SubjectAccessReviewFluentImpl(SubjectAccessReview instance){
            this.withApiVersion(instance.getApiVersion()); 
            this.withContent(instance.getContent()); 
            this.withGroups(instance.getGroups()); 
            this.withIsNonResourceURL(instance.getIsNonResourceURL()); 
            this.withKind(instance.getKind()); 
            this.withNamespace(instance.getNamespace()); 
            this.withPath(instance.getPath()); 
            this.withResource(instance.getResource()); 
            this.withResourceAPIGroup(instance.getResourceAPIGroup()); 
            this.withResourceAPIVersion(instance.getResourceAPIVersion()); 
            this.withResourceName(instance.getResourceName()); 
            this.withScopes(instance.getScopes()); 
            this.withUser(instance.getUser()); 
            this.withVerb(instance.getVerb()); 
    }

    public String getApiVersion(){
            return this.apiVersion;
    }

    public A withApiVersion(String apiVersion){
            this.apiVersion=apiVersion; return (A) this;
    }

    public Boolean hasApiVersion(){
            return this.apiVersion!=null;
    }

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

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

    public A withContent(HasMetadata content){
            if (content instanceof Ingress){ this.content= new IngressBuilder((Ingress)content); _visitables.add(this.content);}
            if (content instanceof Route){ this.content= new RouteBuilder((Route)content); _visitables.add(this.content);}
            if (content instanceof PolicyBinding){ this.content= new PolicyBindingBuilder((PolicyBinding)content); _visitables.add(this.content);}
            if (content instanceof ResourceQuota){ this.content= new ResourceQuotaBuilder((ResourceQuota)content); _visitables.add(this.content);}
            if (content instanceof ServiceAccount){ this.content= new ServiceAccountBuilder((ServiceAccount)content); _visitables.add(this.content);}
            if (content instanceof ConfigMap){ this.content= new ConfigMapBuilder((ConfigMap)content); _visitables.add(this.content);}
            if (content instanceof OAuthClientAuthorization){ this.content= new OAuthClientAuthorizationBuilder((OAuthClientAuthorization)content); _visitables.add(this.content);}
            if (content instanceof Policy){ this.content= new PolicyBuilder((Policy)content); _visitables.add(this.content);}
            if (content instanceof OAuthAuthorizeToken){ this.content= new OAuthAuthorizeTokenBuilder((OAuthAuthorizeToken)content); _visitables.add(this.content);}
            if (content instanceof JenkinsBinding){ this.content= new JenkinsBindingBuilder((JenkinsBinding)content); _visitables.add(this.content);}
            if (content instanceof Identity){ this.content= new IdentityBuilder((Identity)content); _visitables.add(this.content);}
            if (content instanceof PodTemplate){ this.content= new PodTemplateBuilder((PodTemplate)content); _visitables.add(this.content);}
            if (content instanceof TokenReview){ this.content= new TokenReviewBuilder((TokenReview)content); _visitables.add(this.content);}
            if (content instanceof CustomResourceDefinition){ this.content= new CustomResourceDefinitionBuilder((CustomResourceDefinition)content); _visitables.add(this.content);}
            if (content instanceof ImageSignature){ this.content= new ImageSignatureBuilder((ImageSignature)content); _visitables.add(this.content);}
            if (content instanceof ClusterRole){ this.content= new ClusterRoleBuilder((ClusterRole)content); _visitables.add(this.content);}
            if (content instanceof Namespace){ this.content= new NamespaceBuilder((Namespace)content); _visitables.add(this.content);}
            if (content instanceof ClusterPolicy){ this.content= new ClusterPolicyBuilder((ClusterPolicy)content); _visitables.add(this.content);}
            if (content instanceof Build){ this.content= new BuildBuilder((Build)content); _visitables.add(this.content);}
            if (content instanceof Scale){ this.content= new ScaleBuilder((Scale)content); _visitables.add(this.content);}
            if (content instanceof Pod){ this.content= new PodBuilder((Pod)content); _visitables.add(this.content);}
            if (content instanceof HorizontalPodAutoscaler){ this.content= new HorizontalPodAutoscalerBuilder((HorizontalPodAutoscaler)content); _visitables.add(this.content);}
            if (content instanceof ThirdPartyResource){ this.content= new ThirdPartyResourceBuilder((ThirdPartyResource)content); _visitables.add(this.content);}
            if (content instanceof ImageStreamTag){ this.content= new ImageStreamTagBuilder((ImageStreamTag)content); _visitables.add(this.content);}
            if (content instanceof ComponentStatus){ this.content= new ComponentStatusBuilder((ComponentStatus)content); _visitables.add(this.content);}
            if (content instanceof Secret){ this.content= new SecretBuilder((Secret)content); _visitables.add(this.content);}
            if (content instanceof ReplicationController){ this.content= new ReplicationControllerBuilder((ReplicationController)content); _visitables.add(this.content);}
            if (content instanceof LimitRange){ this.content= new LimitRangeBuilder((LimitRange)content); _visitables.add(this.content);}
            if (content instanceof Endpoints){ this.content= new EndpointsBuilder((Endpoints)content); _visitables.add(this.content);}
            if (content instanceof SecurityContextConstraints){ this.content= new SecurityContextConstraintsBuilder((SecurityContextConstraints)content); _visitables.add(this.content);}
            if (content instanceof Group){ this.content= new GroupBuilder((Group)content); _visitables.add(this.content);}
            if (content instanceof Event){ this.content= new EventBuilder((Event)content); _visitables.add(this.content);}
            if (content instanceof Node){ this.content= new NodeBuilder((Node)content); _visitables.add(this.content);}
            if (content instanceof ReplicaSet){ this.content= new ReplicaSetBuilder((ReplicaSet)content); _visitables.add(this.content);}
            if (content instanceof ClusterRoleBinding){ this.content= new ClusterRoleBindingBuilder((ClusterRoleBinding)content); _visitables.add(this.content);}
            if (content instanceof Jenkins){ this.content= new JenkinsBuilder((Jenkins)content); _visitables.add(this.content);}
            if (content instanceof DaemonSet){ this.content= new DaemonSetBuilder((DaemonSet)content); _visitables.add(this.content);}
            if (content instanceof PodDisruptionBudget){ this.content= new PodDisruptionBudgetBuilder((PodDisruptionBudget)content); _visitables.add(this.content);}
            if (content instanceof ImageStream){ this.content= new ImageStreamBuilder((ImageStream)content); _visitables.add(this.content);}
            if (content instanceof RoleBindingRestriction){ this.content= new RoleBindingRestrictionBuilder((RoleBindingRestriction)content); _visitables.add(this.content);}
            if (content instanceof Binding){ this.content= new BindingBuilder((Binding)content); _visitables.add(this.content);}
            if (content instanceof io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview){ this.content= new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder((io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview)content); _visitables.add(this.content);}
            if (content instanceof StatefulSet){ this.content= new StatefulSetBuilder((StatefulSet)content); _visitables.add(this.content);}
            if (content instanceof PipelineTemplateTaskInstance){ this.content= new PipelineTemplateTaskInstanceBuilder((PipelineTemplateTaskInstance)content); _visitables.add(this.content);}
            if (content instanceof OAuthClient){ this.content= new OAuthClientBuilder((OAuthClient)content); _visitables.add(this.content);}
            if (content instanceof Template){ this.content= new TemplateBuilder((Template)content); _visitables.add(this.content);}
            if (content instanceof BuildConfig){ this.content= new BuildConfigBuilder((BuildConfig)content); _visitables.add(this.content);}
            if (content instanceof PodSecurityPolicy){ this.content= new PodSecurityPolicyBuilder((PodSecurityPolicy)content); _visitables.add(this.content);}
            if (content instanceof Pipeline){ this.content= new PipelineBuilder((Pipeline)content); _visitables.add(this.content);}
            if (content instanceof Role){ this.content= new RoleBuilder((Role)content); _visitables.add(this.content);}
            if (content instanceof CronJob){ this.content= new CronJobBuilder((CronJob)content); _visitables.add(this.content);}
            if (content instanceof User){ this.content= new UserBuilder((User)content); _visitables.add(this.content);}
            if (content instanceof StorageClass){ this.content= new StorageClassBuilder((StorageClass)content); _visitables.add(this.content);}
            if (content instanceof PipelineConfigTemplate){ this.content= new PipelineConfigTemplateBuilder((PipelineConfigTemplate)content); _visitables.add(this.content);}
            if (content instanceof PipelineConfig){ this.content= new PipelineConfigBuilder((PipelineConfig)content); _visitables.add(this.content);}
            if (content instanceof DeploymentConfig){ this.content= new DeploymentConfigBuilder((DeploymentConfig)content); _visitables.add(this.content);}
            if (content instanceof OAuthAccessToken){ this.content= new OAuthAccessTokenBuilder((OAuthAccessToken)content); _visitables.add(this.content);}
            if (content instanceof PersistentVolumeClaim){ this.content= new PersistentVolumeClaimBuilder((PersistentVolumeClaim)content); _visitables.add(this.content);}
            if (content instanceof NetworkPolicy){ this.content= new NetworkPolicyBuilder((NetworkPolicy)content); _visitables.add(this.content);}
            if (content instanceof Image){ this.content= new ImageBuilder((Image)content); _visitables.add(this.content);}
            if (content instanceof Service){ this.content= new ServiceBuilder((Service)content); _visitables.add(this.content);}
            if (content instanceof Job){ this.content= new JobBuilder((Job)content); _visitables.add(this.content);}
            if (content instanceof Deployment){ this.content= new DeploymentBuilder((Deployment)content); _visitables.add(this.content);}
            if (content instanceof ClusterPolicyBinding){ this.content= new ClusterPolicyBindingBuilder((ClusterPolicyBinding)content); _visitables.add(this.content);}
            if (content instanceof Project){ this.content= new ProjectBuilder((Project)content); _visitables.add(this.content);}
            if (content instanceof BuildRequest){ this.content= new BuildRequestBuilder((BuildRequest)content); _visitables.add(this.content);}
            if (content instanceof RoleBinding){ this.content= new RoleBindingBuilder((RoleBinding)content); _visitables.add(this.content);}
            if (content instanceof PersistentVolume){ this.content= new PersistentVolumeBuilder((PersistentVolume)content); _visitables.add(this.content);}
            return (A) this;
    }

    public Boolean hasContent(){
            return this.content!=null;
    }

    public A withIngressContent(Ingress ingressContent){
            _visitables.remove(this.content);
            if (ingressContent!=null){ this.content= new IngressBuilder(ingressContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.IngressContentNested withNewIngressContent(){
            return new IngressContentNestedImpl();
    }

    public SubjectAccessReviewFluent.IngressContentNested withNewIngressContentLike(Ingress item){
            return new IngressContentNestedImpl(item);
    }

    public A withRouteContent(Route routeContent){
            _visitables.remove(this.content);
            if (routeContent!=null){ this.content= new RouteBuilder(routeContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.RouteContentNested withNewRouteContent(){
            return new RouteContentNestedImpl();
    }

    public SubjectAccessReviewFluent.RouteContentNested withNewRouteContentLike(Route item){
            return new RouteContentNestedImpl(item);
    }

    public A withPolicyBindingContent(PolicyBinding policyBindingContent){
            _visitables.remove(this.content);
            if (policyBindingContent!=null){ this.content= new PolicyBindingBuilder(policyBindingContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PolicyBindingContentNested withNewPolicyBindingContent(){
            return new PolicyBindingContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PolicyBindingContentNested withNewPolicyBindingContentLike(PolicyBinding item){
            return new PolicyBindingContentNestedImpl(item);
    }

    public A withResourceQuotaContent(ResourceQuota resourceQuotaContent){
            _visitables.remove(this.content);
            if (resourceQuotaContent!=null){ this.content= new ResourceQuotaBuilder(resourceQuotaContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ResourceQuotaContentNested withNewResourceQuotaContent(){
            return new ResourceQuotaContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ResourceQuotaContentNested withNewResourceQuotaContentLike(ResourceQuota item){
            return new ResourceQuotaContentNestedImpl(item);
    }

    public A withServiceAccountContent(ServiceAccount serviceAccountContent){
            _visitables.remove(this.content);
            if (serviceAccountContent!=null){ this.content= new ServiceAccountBuilder(serviceAccountContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ServiceAccountContentNested withNewServiceAccountContent(){
            return new ServiceAccountContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ServiceAccountContentNested withNewServiceAccountContentLike(ServiceAccount item){
            return new ServiceAccountContentNestedImpl(item);
    }

    public A withConfigMapContent(ConfigMap configMapContent){
            _visitables.remove(this.content);
            if (configMapContent!=null){ this.content= new ConfigMapBuilder(configMapContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ConfigMapContentNested withNewConfigMapContent(){
            return new ConfigMapContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ConfigMapContentNested withNewConfigMapContentLike(ConfigMap item){
            return new ConfigMapContentNestedImpl(item);
    }

    public A withOAuthClientAuthorizationContent(OAuthClientAuthorization oAuthClientAuthorizationContent){
            _visitables.remove(this.content);
            if (oAuthClientAuthorizationContent!=null){ this.content= new OAuthClientAuthorizationBuilder(oAuthClientAuthorizationContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.OAuthClientAuthorizationContentNested withNewOAuthClientAuthorizationContent(){
            return new OAuthClientAuthorizationContentNestedImpl();
    }

    public SubjectAccessReviewFluent.OAuthClientAuthorizationContentNested withNewOAuthClientAuthorizationContentLike(OAuthClientAuthorization item){
            return new OAuthClientAuthorizationContentNestedImpl(item);
    }

    public A withPolicyContent(Policy policyContent){
            _visitables.remove(this.content);
            if (policyContent!=null){ this.content= new PolicyBuilder(policyContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PolicyContentNested withNewPolicyContent(){
            return new PolicyContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PolicyContentNested withNewPolicyContentLike(Policy item){
            return new PolicyContentNestedImpl(item);
    }

    public A withOAuthAuthorizeTokenContent(OAuthAuthorizeToken oAuthAuthorizeTokenContent){
            _visitables.remove(this.content);
            if (oAuthAuthorizeTokenContent!=null){ this.content= new OAuthAuthorizeTokenBuilder(oAuthAuthorizeTokenContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.OAuthAuthorizeTokenContentNested withNewOAuthAuthorizeTokenContent(){
            return new OAuthAuthorizeTokenContentNestedImpl();
    }

    public SubjectAccessReviewFluent.OAuthAuthorizeTokenContentNested withNewOAuthAuthorizeTokenContentLike(OAuthAuthorizeToken item){
            return new OAuthAuthorizeTokenContentNestedImpl(item);
    }

    public A withJenkinsBindingContent(JenkinsBinding jenkinsBindingContent){
            _visitables.remove(this.content);
            if (jenkinsBindingContent!=null){ this.content= new JenkinsBindingBuilder(jenkinsBindingContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.JenkinsBindingContentNested withNewJenkinsBindingContent(){
            return new JenkinsBindingContentNestedImpl();
    }

    public SubjectAccessReviewFluent.JenkinsBindingContentNested withNewJenkinsBindingContentLike(JenkinsBinding item){
            return new JenkinsBindingContentNestedImpl(item);
    }

    public A withIdentityContent(Identity identityContent){
            _visitables.remove(this.content);
            if (identityContent!=null){ this.content= new IdentityBuilder(identityContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.IdentityContentNested withNewIdentityContent(){
            return new IdentityContentNestedImpl();
    }

    public SubjectAccessReviewFluent.IdentityContentNested withNewIdentityContentLike(Identity item){
            return new IdentityContentNestedImpl(item);
    }

    public A withPodTemplateContent(PodTemplate podTemplateContent){
            _visitables.remove(this.content);
            if (podTemplateContent!=null){ this.content= new PodTemplateBuilder(podTemplateContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PodTemplateContentNested withNewPodTemplateContent(){
            return new PodTemplateContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PodTemplateContentNested withNewPodTemplateContentLike(PodTemplate item){
            return new PodTemplateContentNestedImpl(item);
    }

    public A withTokenReviewContent(TokenReview tokenReviewContent){
            _visitables.remove(this.content);
            if (tokenReviewContent!=null){ this.content= new TokenReviewBuilder(tokenReviewContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.TokenReviewContentNested withNewTokenReviewContent(){
            return new TokenReviewContentNestedImpl();
    }

    public SubjectAccessReviewFluent.TokenReviewContentNested withNewTokenReviewContentLike(TokenReview item){
            return new TokenReviewContentNestedImpl(item);
    }

    public A withCustomResourceDefinitionContent(CustomResourceDefinition customResourceDefinitionContent){
            _visitables.remove(this.content);
            if (customResourceDefinitionContent!=null){ this.content= new CustomResourceDefinitionBuilder(customResourceDefinitionContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.CustomResourceDefinitionContentNested withNewCustomResourceDefinitionContent(){
            return new CustomResourceDefinitionContentNestedImpl();
    }

    public SubjectAccessReviewFluent.CustomResourceDefinitionContentNested withNewCustomResourceDefinitionContentLike(CustomResourceDefinition item){
            return new CustomResourceDefinitionContentNestedImpl(item);
    }

    public A withImageSignatureContent(ImageSignature imageSignatureContent){
            _visitables.remove(this.content);
            if (imageSignatureContent!=null){ this.content= new ImageSignatureBuilder(imageSignatureContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ImageSignatureContentNested withNewImageSignatureContent(){
            return new ImageSignatureContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ImageSignatureContentNested withNewImageSignatureContentLike(ImageSignature item){
            return new ImageSignatureContentNestedImpl(item);
    }

    public A withClusterRoleContent(ClusterRole clusterRoleContent){
            _visitables.remove(this.content);
            if (clusterRoleContent!=null){ this.content= new ClusterRoleBuilder(clusterRoleContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ClusterRoleContentNested withNewClusterRoleContent(){
            return new ClusterRoleContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ClusterRoleContentNested withNewClusterRoleContentLike(ClusterRole item){
            return new ClusterRoleContentNestedImpl(item);
    }

    public A withNamespaceContent(Namespace namespaceContent){
            _visitables.remove(this.content);
            if (namespaceContent!=null){ this.content= new NamespaceBuilder(namespaceContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.NamespaceContentNested withNewNamespaceContent(){
            return new NamespaceContentNestedImpl();
    }

    public SubjectAccessReviewFluent.NamespaceContentNested withNewNamespaceContentLike(Namespace item){
            return new NamespaceContentNestedImpl(item);
    }

    public A withClusterPolicyContent(ClusterPolicy clusterPolicyContent){
            _visitables.remove(this.content);
            if (clusterPolicyContent!=null){ this.content= new ClusterPolicyBuilder(clusterPolicyContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ClusterPolicyContentNested withNewClusterPolicyContent(){
            return new ClusterPolicyContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ClusterPolicyContentNested withNewClusterPolicyContentLike(ClusterPolicy item){
            return new ClusterPolicyContentNestedImpl(item);
    }

    public A withBuildContent(Build buildContent){
            _visitables.remove(this.content);
            if (buildContent!=null){ this.content= new BuildBuilder(buildContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.BuildContentNested withNewBuildContent(){
            return new BuildContentNestedImpl();
    }

    public SubjectAccessReviewFluent.BuildContentNested withNewBuildContentLike(Build item){
            return new BuildContentNestedImpl(item);
    }

    public A withScaleContent(Scale scaleContent){
            _visitables.remove(this.content);
            if (scaleContent!=null){ this.content= new ScaleBuilder(scaleContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ScaleContentNested withNewScaleContent(){
            return new ScaleContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ScaleContentNested withNewScaleContentLike(Scale item){
            return new ScaleContentNestedImpl(item);
    }

    public A withPodContent(Pod podContent){
            _visitables.remove(this.content);
            if (podContent!=null){ this.content= new PodBuilder(podContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PodContentNested withNewPodContent(){
            return new PodContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PodContentNested withNewPodContentLike(Pod item){
            return new PodContentNestedImpl(item);
    }

    public A withHorizontalPodAutoscalerContent(HorizontalPodAutoscaler horizontalPodAutoscalerContent){
            _visitables.remove(this.content);
            if (horizontalPodAutoscalerContent!=null){ this.content= new HorizontalPodAutoscalerBuilder(horizontalPodAutoscalerContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.HorizontalPodAutoscalerContentNested withNewHorizontalPodAutoscalerContent(){
            return new HorizontalPodAutoscalerContentNestedImpl();
    }

    public SubjectAccessReviewFluent.HorizontalPodAutoscalerContentNested withNewHorizontalPodAutoscalerContentLike(HorizontalPodAutoscaler item){
            return new HorizontalPodAutoscalerContentNestedImpl(item);
    }

    public A withThirdPartyResourceContent(ThirdPartyResource thirdPartyResourceContent){
            _visitables.remove(this.content);
            if (thirdPartyResourceContent!=null){ this.content= new ThirdPartyResourceBuilder(thirdPartyResourceContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ThirdPartyResourceContentNested withNewThirdPartyResourceContent(){
            return new ThirdPartyResourceContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ThirdPartyResourceContentNested withNewThirdPartyResourceContentLike(ThirdPartyResource item){
            return new ThirdPartyResourceContentNestedImpl(item);
    }

    public A withImageStreamTagContent(ImageStreamTag imageStreamTagContent){
            _visitables.remove(this.content);
            if (imageStreamTagContent!=null){ this.content= new ImageStreamTagBuilder(imageStreamTagContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ImageStreamTagContentNested withNewImageStreamTagContent(){
            return new ImageStreamTagContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ImageStreamTagContentNested withNewImageStreamTagContentLike(ImageStreamTag item){
            return new ImageStreamTagContentNestedImpl(item);
    }

    public A withComponentStatusContent(ComponentStatus componentStatusContent){
            _visitables.remove(this.content);
            if (componentStatusContent!=null){ this.content= new ComponentStatusBuilder(componentStatusContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ComponentStatusContentNested withNewComponentStatusContent(){
            return new ComponentStatusContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ComponentStatusContentNested withNewComponentStatusContentLike(ComponentStatus item){
            return new ComponentStatusContentNestedImpl(item);
    }

    public A withSecretContent(Secret secretContent){
            _visitables.remove(this.content);
            if (secretContent!=null){ this.content= new SecretBuilder(secretContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.SecretContentNested withNewSecretContent(){
            return new SecretContentNestedImpl();
    }

    public SubjectAccessReviewFluent.SecretContentNested withNewSecretContentLike(Secret item){
            return new SecretContentNestedImpl(item);
    }

    public A withReplicationControllerContent(ReplicationController replicationControllerContent){
            _visitables.remove(this.content);
            if (replicationControllerContent!=null){ this.content= new ReplicationControllerBuilder(replicationControllerContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ReplicationControllerContentNested withNewReplicationControllerContent(){
            return new ReplicationControllerContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ReplicationControllerContentNested withNewReplicationControllerContentLike(ReplicationController item){
            return new ReplicationControllerContentNestedImpl(item);
    }

    public A withLimitRangeContent(LimitRange limitRangeContent){
            _visitables.remove(this.content);
            if (limitRangeContent!=null){ this.content= new LimitRangeBuilder(limitRangeContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.LimitRangeContentNested withNewLimitRangeContent(){
            return new LimitRangeContentNestedImpl();
    }

    public SubjectAccessReviewFluent.LimitRangeContentNested withNewLimitRangeContentLike(LimitRange item){
            return new LimitRangeContentNestedImpl(item);
    }

    public A withEndpointsContent(Endpoints endpointsContent){
            _visitables.remove(this.content);
            if (endpointsContent!=null){ this.content= new EndpointsBuilder(endpointsContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.EndpointsContentNested withNewEndpointsContent(){
            return new EndpointsContentNestedImpl();
    }

    public SubjectAccessReviewFluent.EndpointsContentNested withNewEndpointsContentLike(Endpoints item){
            return new EndpointsContentNestedImpl(item);
    }

    public A withSecurityContextConstraintsContent(SecurityContextConstraints securityContextConstraintsContent){
            _visitables.remove(this.content);
            if (securityContextConstraintsContent!=null){ this.content= new SecurityContextConstraintsBuilder(securityContextConstraintsContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.SecurityContextConstraintsContentNested withNewSecurityContextConstraintsContent(){
            return new SecurityContextConstraintsContentNestedImpl();
    }

    public SubjectAccessReviewFluent.SecurityContextConstraintsContentNested withNewSecurityContextConstraintsContentLike(SecurityContextConstraints item){
            return new SecurityContextConstraintsContentNestedImpl(item);
    }

    public A withGroupContent(Group groupContent){
            _visitables.remove(this.content);
            if (groupContent!=null){ this.content= new GroupBuilder(groupContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.GroupContentNested withNewGroupContent(){
            return new GroupContentNestedImpl();
    }

    public SubjectAccessReviewFluent.GroupContentNested withNewGroupContentLike(Group item){
            return new GroupContentNestedImpl(item);
    }

    public A withEventContent(Event eventContent){
            _visitables.remove(this.content);
            if (eventContent!=null){ this.content= new EventBuilder(eventContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.EventContentNested withNewEventContent(){
            return new EventContentNestedImpl();
    }

    public SubjectAccessReviewFluent.EventContentNested withNewEventContentLike(Event item){
            return new EventContentNestedImpl(item);
    }

    public A withNodeContent(Node nodeContent){
            _visitables.remove(this.content);
            if (nodeContent!=null){ this.content= new NodeBuilder(nodeContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.NodeContentNested withNewNodeContent(){
            return new NodeContentNestedImpl();
    }

    public SubjectAccessReviewFluent.NodeContentNested withNewNodeContentLike(Node item){
            return new NodeContentNestedImpl(item);
    }

    public A withReplicaSetContent(ReplicaSet replicaSetContent){
            _visitables.remove(this.content);
            if (replicaSetContent!=null){ this.content= new ReplicaSetBuilder(replicaSetContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ReplicaSetContentNested withNewReplicaSetContent(){
            return new ReplicaSetContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ReplicaSetContentNested withNewReplicaSetContentLike(ReplicaSet item){
            return new ReplicaSetContentNestedImpl(item);
    }

    public A withClusterRoleBindingContent(ClusterRoleBinding clusterRoleBindingContent){
            _visitables.remove(this.content);
            if (clusterRoleBindingContent!=null){ this.content= new ClusterRoleBindingBuilder(clusterRoleBindingContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ClusterRoleBindingContentNested withNewClusterRoleBindingContent(){
            return new ClusterRoleBindingContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ClusterRoleBindingContentNested withNewClusterRoleBindingContentLike(ClusterRoleBinding item){
            return new ClusterRoleBindingContentNestedImpl(item);
    }

    public A withJenkinsContent(Jenkins jenkinsContent){
            _visitables.remove(this.content);
            if (jenkinsContent!=null){ this.content= new JenkinsBuilder(jenkinsContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.JenkinsContentNested withNewJenkinsContent(){
            return new JenkinsContentNestedImpl();
    }

    public SubjectAccessReviewFluent.JenkinsContentNested withNewJenkinsContentLike(Jenkins item){
            return new JenkinsContentNestedImpl(item);
    }

    public A withDaemonSetContent(DaemonSet daemonSetContent){
            _visitables.remove(this.content);
            if (daemonSetContent!=null){ this.content= new DaemonSetBuilder(daemonSetContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.DaemonSetContentNested withNewDaemonSetContent(){
            return new DaemonSetContentNestedImpl();
    }

    public SubjectAccessReviewFluent.DaemonSetContentNested withNewDaemonSetContentLike(DaemonSet item){
            return new DaemonSetContentNestedImpl(item);
    }

    public A withPodDisruptionBudgetContent(PodDisruptionBudget podDisruptionBudgetContent){
            _visitables.remove(this.content);
            if (podDisruptionBudgetContent!=null){ this.content= new PodDisruptionBudgetBuilder(podDisruptionBudgetContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PodDisruptionBudgetContentNested withNewPodDisruptionBudgetContent(){
            return new PodDisruptionBudgetContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PodDisruptionBudgetContentNested withNewPodDisruptionBudgetContentLike(PodDisruptionBudget item){
            return new PodDisruptionBudgetContentNestedImpl(item);
    }

    public A withImageStreamContent(ImageStream imageStreamContent){
            _visitables.remove(this.content);
            if (imageStreamContent!=null){ this.content= new ImageStreamBuilder(imageStreamContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ImageStreamContentNested withNewImageStreamContent(){
            return new ImageStreamContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ImageStreamContentNested withNewImageStreamContentLike(ImageStream item){
            return new ImageStreamContentNestedImpl(item);
    }

    public A withRoleBindingRestrictionContent(RoleBindingRestriction roleBindingRestrictionContent){
            _visitables.remove(this.content);
            if (roleBindingRestrictionContent!=null){ this.content= new RoleBindingRestrictionBuilder(roleBindingRestrictionContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.RoleBindingRestrictionContentNested withNewRoleBindingRestrictionContent(){
            return new RoleBindingRestrictionContentNestedImpl();
    }

    public SubjectAccessReviewFluent.RoleBindingRestrictionContentNested withNewRoleBindingRestrictionContentLike(RoleBindingRestriction item){
            return new RoleBindingRestrictionContentNestedImpl(item);
    }

    public A withBindingContent(Binding bindingContent){
            _visitables.remove(this.content);
            if (bindingContent!=null){ this.content= new BindingBuilder(bindingContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.BindingContentNested withNewBindingContent(){
            return new BindingContentNestedImpl();
    }

    public SubjectAccessReviewFluent.BindingContentNested withNewBindingContentLike(Binding item){
            return new BindingContentNestedImpl(item);
    }

    public A withLocalSubjectAccessReviewContent(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview localSubjectAccessReviewContent){
            _visitables.remove(this.content);
            if (localSubjectAccessReviewContent!=null){ this.content= new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(localSubjectAccessReviewContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.AuthorizationLocalSubjectAccessReviewContentNested withNewAuthorizationLocalSubjectAccessReviewContent(){
            return new AuthorizationLocalSubjectAccessReviewContentNestedImpl();
    }

    public SubjectAccessReviewFluent.AuthorizationLocalSubjectAccessReviewContentNested withNewLocalSubjectAccessReviewContentLike(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
            return new AuthorizationLocalSubjectAccessReviewContentNestedImpl(item);
    }

    public A withStatefulSetContent(StatefulSet statefulSetContent){
            _visitables.remove(this.content);
            if (statefulSetContent!=null){ this.content= new StatefulSetBuilder(statefulSetContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.StatefulSetContentNested withNewStatefulSetContent(){
            return new StatefulSetContentNestedImpl();
    }

    public SubjectAccessReviewFluent.StatefulSetContentNested withNewStatefulSetContentLike(StatefulSet item){
            return new StatefulSetContentNestedImpl(item);
    }

    public A withPipelineTemplateTaskInstanceContent(PipelineTemplateTaskInstance pipelineTemplateTaskInstanceContent){
            _visitables.remove(this.content);
            if (pipelineTemplateTaskInstanceContent!=null){ this.content= new PipelineTemplateTaskInstanceBuilder(pipelineTemplateTaskInstanceContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PipelineTemplateTaskInstanceContentNested withNewPipelineTemplateTaskInstanceContent(){
            return new PipelineTemplateTaskInstanceContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PipelineTemplateTaskInstanceContentNested withNewPipelineTemplateTaskInstanceContentLike(PipelineTemplateTaskInstance item){
            return new PipelineTemplateTaskInstanceContentNestedImpl(item);
    }

    public A withOAuthClientContent(OAuthClient oAuthClientContent){
            _visitables.remove(this.content);
            if (oAuthClientContent!=null){ this.content= new OAuthClientBuilder(oAuthClientContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.OAuthClientContentNested withNewOAuthClientContent(){
            return new OAuthClientContentNestedImpl();
    }

    public SubjectAccessReviewFluent.OAuthClientContentNested withNewOAuthClientContentLike(OAuthClient item){
            return new OAuthClientContentNestedImpl(item);
    }

    public A withTemplateContent(Template templateContent){
            _visitables.remove(this.content);
            if (templateContent!=null){ this.content= new TemplateBuilder(templateContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.TemplateContentNested withNewTemplateContent(){
            return new TemplateContentNestedImpl();
    }

    public SubjectAccessReviewFluent.TemplateContentNested withNewTemplateContentLike(Template item){
            return new TemplateContentNestedImpl(item);
    }

    public A withBuildConfigContent(BuildConfig buildConfigContent){
            _visitables.remove(this.content);
            if (buildConfigContent!=null){ this.content= new BuildConfigBuilder(buildConfigContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.BuildConfigContentNested withNewBuildConfigContent(){
            return new BuildConfigContentNestedImpl();
    }

    public SubjectAccessReviewFluent.BuildConfigContentNested withNewBuildConfigContentLike(BuildConfig item){
            return new BuildConfigContentNestedImpl(item);
    }

    public A withPodSecurityPolicyContent(PodSecurityPolicy podSecurityPolicyContent){
            _visitables.remove(this.content);
            if (podSecurityPolicyContent!=null){ this.content= new PodSecurityPolicyBuilder(podSecurityPolicyContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PodSecurityPolicyContentNested withNewPodSecurityPolicyContent(){
            return new PodSecurityPolicyContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PodSecurityPolicyContentNested withNewPodSecurityPolicyContentLike(PodSecurityPolicy item){
            return new PodSecurityPolicyContentNestedImpl(item);
    }

    public A withPipelineContent(Pipeline pipelineContent){
            _visitables.remove(this.content);
            if (pipelineContent!=null){ this.content= new PipelineBuilder(pipelineContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PipelineContentNested withNewPipelineContent(){
            return new PipelineContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PipelineContentNested withNewPipelineContentLike(Pipeline item){
            return new PipelineContentNestedImpl(item);
    }

    public A withRoleContent(Role roleContent){
            _visitables.remove(this.content);
            if (roleContent!=null){ this.content= new RoleBuilder(roleContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.RoleContentNested withNewRoleContent(){
            return new RoleContentNestedImpl();
    }

    public SubjectAccessReviewFluent.RoleContentNested withNewRoleContentLike(Role item){
            return new RoleContentNestedImpl(item);
    }

    public A withCronJobContent(CronJob cronJobContent){
            _visitables.remove(this.content);
            if (cronJobContent!=null){ this.content= new CronJobBuilder(cronJobContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.CronJobContentNested withNewCronJobContent(){
            return new CronJobContentNestedImpl();
    }

    public SubjectAccessReviewFluent.CronJobContentNested withNewCronJobContentLike(CronJob item){
            return new CronJobContentNestedImpl(item);
    }

    public A withUserContent(User userContent){
            _visitables.remove(this.content);
            if (userContent!=null){ this.content= new UserBuilder(userContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.UserContentNested withNewUserContent(){
            return new UserContentNestedImpl();
    }

    public SubjectAccessReviewFluent.UserContentNested withNewUserContentLike(User item){
            return new UserContentNestedImpl(item);
    }

    public A withStorageClassContent(StorageClass storageClassContent){
            _visitables.remove(this.content);
            if (storageClassContent!=null){ this.content= new StorageClassBuilder(storageClassContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.StorageClassContentNested withNewStorageClassContent(){
            return new StorageClassContentNestedImpl();
    }

    public SubjectAccessReviewFluent.StorageClassContentNested withNewStorageClassContentLike(StorageClass item){
            return new StorageClassContentNestedImpl(item);
    }

    public A withPipelineConfigTemplateContent(PipelineConfigTemplate pipelineConfigTemplateContent){
            _visitables.remove(this.content);
            if (pipelineConfigTemplateContent!=null){ this.content= new PipelineConfigTemplateBuilder(pipelineConfigTemplateContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PipelineConfigTemplateContentNested withNewPipelineConfigTemplateContent(){
            return new PipelineConfigTemplateContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PipelineConfigTemplateContentNested withNewPipelineConfigTemplateContentLike(PipelineConfigTemplate item){
            return new PipelineConfigTemplateContentNestedImpl(item);
    }

    public A withPipelineConfigContent(PipelineConfig pipelineConfigContent){
            _visitables.remove(this.content);
            if (pipelineConfigContent!=null){ this.content= new PipelineConfigBuilder(pipelineConfigContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PipelineConfigContentNested withNewPipelineConfigContent(){
            return new PipelineConfigContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PipelineConfigContentNested withNewPipelineConfigContentLike(PipelineConfig item){
            return new PipelineConfigContentNestedImpl(item);
    }

    public A withDeploymentConfigContent(DeploymentConfig deploymentConfigContent){
            _visitables.remove(this.content);
            if (deploymentConfigContent!=null){ this.content= new DeploymentConfigBuilder(deploymentConfigContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.DeploymentConfigContentNested withNewDeploymentConfigContent(){
            return new DeploymentConfigContentNestedImpl();
    }

    public SubjectAccessReviewFluent.DeploymentConfigContentNested withNewDeploymentConfigContentLike(DeploymentConfig item){
            return new DeploymentConfigContentNestedImpl(item);
    }

    public A withOAuthAccessTokenContent(OAuthAccessToken oAuthAccessTokenContent){
            _visitables.remove(this.content);
            if (oAuthAccessTokenContent!=null){ this.content= new OAuthAccessTokenBuilder(oAuthAccessTokenContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.OAuthAccessTokenContentNested withNewOAuthAccessTokenContent(){
            return new OAuthAccessTokenContentNestedImpl();
    }

    public SubjectAccessReviewFluent.OAuthAccessTokenContentNested withNewOAuthAccessTokenContentLike(OAuthAccessToken item){
            return new OAuthAccessTokenContentNestedImpl(item);
    }

    public A withPersistentVolumeClaimContent(PersistentVolumeClaim persistentVolumeClaimContent){
            _visitables.remove(this.content);
            if (persistentVolumeClaimContent!=null){ this.content= new PersistentVolumeClaimBuilder(persistentVolumeClaimContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PersistentVolumeClaimContentNested withNewPersistentVolumeClaimContent(){
            return new PersistentVolumeClaimContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PersistentVolumeClaimContentNested withNewPersistentVolumeClaimContentLike(PersistentVolumeClaim item){
            return new PersistentVolumeClaimContentNestedImpl(item);
    }

    public A withNetworkPolicyContent(NetworkPolicy networkPolicyContent){
            _visitables.remove(this.content);
            if (networkPolicyContent!=null){ this.content= new NetworkPolicyBuilder(networkPolicyContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.NetworkPolicyContentNested withNewNetworkPolicyContent(){
            return new NetworkPolicyContentNestedImpl();
    }

    public SubjectAccessReviewFluent.NetworkPolicyContentNested withNewNetworkPolicyContentLike(NetworkPolicy item){
            return new NetworkPolicyContentNestedImpl(item);
    }

    public A withImageContent(Image imageContent){
            _visitables.remove(this.content);
            if (imageContent!=null){ this.content= new ImageBuilder(imageContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ImageContentNested withNewImageContent(){
            return new ImageContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ImageContentNested withNewImageContentLike(Image item){
            return new ImageContentNestedImpl(item);
    }

    public A withServiceContent(Service serviceContent){
            _visitables.remove(this.content);
            if (serviceContent!=null){ this.content= new ServiceBuilder(serviceContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ServiceContentNested withNewServiceContent(){
            return new ServiceContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ServiceContentNested withNewServiceContentLike(Service item){
            return new ServiceContentNestedImpl(item);
    }

    public A withJobContent(Job jobContent){
            _visitables.remove(this.content);
            if (jobContent!=null){ this.content= new JobBuilder(jobContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.JobContentNested withNewJobContent(){
            return new JobContentNestedImpl();
    }

    public SubjectAccessReviewFluent.JobContentNested withNewJobContentLike(Job item){
            return new JobContentNestedImpl(item);
    }

    public A withDeploymentContent(Deployment deploymentContent){
            _visitables.remove(this.content);
            if (deploymentContent!=null){ this.content= new DeploymentBuilder(deploymentContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.DeploymentContentNested withNewDeploymentContent(){
            return new DeploymentContentNestedImpl();
    }

    public SubjectAccessReviewFluent.DeploymentContentNested withNewDeploymentContentLike(Deployment item){
            return new DeploymentContentNestedImpl(item);
    }

    public A withClusterPolicyBindingContent(ClusterPolicyBinding clusterPolicyBindingContent){
            _visitables.remove(this.content);
            if (clusterPolicyBindingContent!=null){ this.content= new ClusterPolicyBindingBuilder(clusterPolicyBindingContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ClusterPolicyBindingContentNested withNewClusterPolicyBindingContent(){
            return new ClusterPolicyBindingContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ClusterPolicyBindingContentNested withNewClusterPolicyBindingContentLike(ClusterPolicyBinding item){
            return new ClusterPolicyBindingContentNestedImpl(item);
    }

    public A withProjectContent(Project projectContent){
            _visitables.remove(this.content);
            if (projectContent!=null){ this.content= new ProjectBuilder(projectContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.ProjectContentNested withNewProjectContent(){
            return new ProjectContentNestedImpl();
    }

    public SubjectAccessReviewFluent.ProjectContentNested withNewProjectContentLike(Project item){
            return new ProjectContentNestedImpl(item);
    }

    public A withBuildRequestContent(BuildRequest buildRequestContent){
            _visitables.remove(this.content);
            if (buildRequestContent!=null){ this.content= new BuildRequestBuilder(buildRequestContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.BuildRequestContentNested withNewBuildRequestContent(){
            return new BuildRequestContentNestedImpl();
    }

    public SubjectAccessReviewFluent.BuildRequestContentNested withNewBuildRequestContentLike(BuildRequest item){
            return new BuildRequestContentNestedImpl(item);
    }

    public A withRoleBindingContent(RoleBinding roleBindingContent){
            _visitables.remove(this.content);
            if (roleBindingContent!=null){ this.content= new RoleBindingBuilder(roleBindingContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.RoleBindingContentNested withNewRoleBindingContent(){
            return new RoleBindingContentNestedImpl();
    }

    public SubjectAccessReviewFluent.RoleBindingContentNested withNewRoleBindingContentLike(RoleBinding item){
            return new RoleBindingContentNestedImpl(item);
    }

    public A withPersistentVolumeContent(PersistentVolume persistentVolumeContent){
            _visitables.remove(this.content);
            if (persistentVolumeContent!=null){ this.content= new PersistentVolumeBuilder(persistentVolumeContent); _visitables.add(this.content);} return (A) this;
    }

    public SubjectAccessReviewFluent.PersistentVolumeContentNested withNewPersistentVolumeContent(){
            return new PersistentVolumeContentNestedImpl();
    }

    public SubjectAccessReviewFluent.PersistentVolumeContentNested withNewPersistentVolumeContentLike(PersistentVolume item){
            return new PersistentVolumeContentNestedImpl(item);
    }

    public A addToGroups(int index,String item){
            this.groups.add(index, item); return (A)this;
    }

    public A setToGroups(int index,String item){
            this.groups.set(index, item); return (A)this;
    }

    public A addToGroups(String... items){
            for (String item : items) {this.groups.add(item);} return (A)this;
    }

    public A addAllToGroups(Collection items){
            for (String item : items) {this.groups.add(item);} return (A)this;
    }

    public A removeFromGroups(String... items){
            for (String item : items) {this.groups.remove(item);} return (A)this;
    }

    public A removeAllFromGroups(Collection items){
            for (String item : items) {this.groups.remove(item);} return (A)this;
    }

    public List getGroups(){
            return this.groups;
    }

    public String getGroup(int index){
            return this.groups.get(index);
    }

    public String getFirstGroup(){
            return this.groups.get(0);
    }

    public String getLastGroup(){
            return this.groups.get(groups.size() - 1);
    }

    public String getMatchingGroup(io.alauda.kubernetes.api.builder.Predicate predicate){
            for (String item: groups) { if(predicate.apply(item)){return item;} } return null;
    }

    public A withGroups(List groups){
            this.groups.clear();
            if (groups != null) {for (String item : groups){this.addToGroups(item);}} return (A) this;
    }

    public A withGroups(String... groups){
            this.groups.clear(); if (groups != null) {for (String item :groups){ this.addToGroups(item);}} return (A) this;
    }

    public Boolean hasGroups(){
            return groups!= null && !groups.isEmpty();
    }

    public Boolean isIsNonResourceURL(){
            return this.isNonResourceURL;
    }

    public A withIsNonResourceURL(Boolean isNonResourceURL){
            this.isNonResourceURL=isNonResourceURL; return (A) this;
    }

    public Boolean hasIsNonResourceURL(){
            return this.isNonResourceURL!=null;
    }

    public String getKind(){
            return this.kind;
    }

    public A withKind(String kind){
            this.kind=kind; return (A) this;
    }

    public Boolean hasKind(){
            return this.kind!=null;
    }

    public String getNamespace(){
            return this.namespace;
    }

    public A withNamespace(String namespace){
            this.namespace=namespace; return (A) this;
    }

    public Boolean hasNamespace(){
            return this.namespace!=null;
    }

    public String getPath(){
            return this.path;
    }

    public A withPath(String path){
            this.path=path; return (A) this;
    }

    public Boolean hasPath(){
            return this.path!=null;
    }

    public String getResource(){
            return this.resource;
    }

    public A withResource(String resource){
            this.resource=resource; return (A) this;
    }

    public Boolean hasResource(){
            return this.resource!=null;
    }

    public String getResourceAPIGroup(){
            return this.resourceAPIGroup;
    }

    public A withResourceAPIGroup(String resourceAPIGroup){
            this.resourceAPIGroup=resourceAPIGroup; return (A) this;
    }

    public Boolean hasResourceAPIGroup(){
            return this.resourceAPIGroup!=null;
    }

    public String getResourceAPIVersion(){
            return this.resourceAPIVersion;
    }

    public A withResourceAPIVersion(String resourceAPIVersion){
            this.resourceAPIVersion=resourceAPIVersion; return (A) this;
    }

    public Boolean hasResourceAPIVersion(){
            return this.resourceAPIVersion!=null;
    }

    public String getResourceName(){
            return this.resourceName;
    }

    public A withResourceName(String resourceName){
            this.resourceName=resourceName; return (A) this;
    }

    public Boolean hasResourceName(){
            return this.resourceName!=null;
    }

    public A addToScopes(int index,String item){
            this.scopes.add(index, item); return (A)this;
    }

    public A setToScopes(int index,String item){
            this.scopes.set(index, item); return (A)this;
    }

    public A addToScopes(String... items){
            for (String item : items) {this.scopes.add(item);} return (A)this;
    }

    public A addAllToScopes(Collection items){
            for (String item : items) {this.scopes.add(item);} return (A)this;
    }

    public A removeFromScopes(String... items){
            for (String item : items) {this.scopes.remove(item);} return (A)this;
    }

    public A removeAllFromScopes(Collection items){
            for (String item : items) {this.scopes.remove(item);} return (A)this;
    }

    public List getScopes(){
            return this.scopes;
    }

    public String getScope(int index){
            return this.scopes.get(index);
    }

    public String getFirstScope(){
            return this.scopes.get(0);
    }

    public String getLastScope(){
            return this.scopes.get(scopes.size() - 1);
    }

    public String getMatchingScope(io.alauda.kubernetes.api.builder.Predicate predicate){
            for (String item: scopes) { if(predicate.apply(item)){return item;} } return null;
    }

    public A withScopes(List scopes){
            this.scopes.clear();
            if (scopes != null) {for (String item : scopes){this.addToScopes(item);}} return (A) this;
    }

    public A withScopes(String... scopes){
            this.scopes.clear(); if (scopes != null) {for (String item :scopes){ this.addToScopes(item);}} return (A) this;
    }

    public Boolean hasScopes(){
            return scopes!= null && !scopes.isEmpty();
    }

    public String getUser(){
            return this.user;
    }

    public A withUser(String user){
            this.user=user; return (A) this;
    }

    public Boolean hasUser(){
            return this.user!=null;
    }

    public String getVerb(){
            return this.verb;
    }

    public A withVerb(String verb){
            this.verb=verb; return (A) this;
    }

    public Boolean hasVerb(){
            return this.verb!=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;
            SubjectAccessReviewFluentImpl that = (SubjectAccessReviewFluentImpl) o;
            if (apiVersion != null ? !apiVersion.equals(that.apiVersion) :that.apiVersion != null) return false;
            if (content != null ? !content.equals(that.content) :that.content != null) return false;
            if (groups != null ? !groups.equals(that.groups) :that.groups != null) return false;
            if (isNonResourceURL != null ? !isNonResourceURL.equals(that.isNonResourceURL) :that.isNonResourceURL != null) return false;
            if (kind != null ? !kind.equals(that.kind) :that.kind != null) return false;
            if (namespace != null ? !namespace.equals(that.namespace) :that.namespace != null) return false;
            if (path != null ? !path.equals(that.path) :that.path != null) return false;
            if (resource != null ? !resource.equals(that.resource) :that.resource != null) return false;
            if (resourceAPIGroup != null ? !resourceAPIGroup.equals(that.resourceAPIGroup) :that.resourceAPIGroup != null) return false;
            if (resourceAPIVersion != null ? !resourceAPIVersion.equals(that.resourceAPIVersion) :that.resourceAPIVersion != null) return false;
            if (resourceName != null ? !resourceName.equals(that.resourceName) :that.resourceName != null) return false;
            if (scopes != null ? !scopes.equals(that.scopes) :that.scopes != null) return false;
            if (user != null ? !user.equals(that.user) :that.user != null) return false;
            if (verb != null ? !verb.equals(that.verb) :that.verb != null) return false;
            return true;
    }


    public class IngressContentNestedImpl extends IngressFluentImpl> implements SubjectAccessReviewFluent.IngressContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressBuilder builder;
    
            IngressContentNestedImpl(Ingress item){
                    this.builder = new IngressBuilder(this, item);
            }
            IngressContentNestedImpl(){
                    this.builder = new IngressBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withIngressContent(builder.build());
    }
    public N endIngressContent(){
            return and();
    }

}
    public class RouteContentNestedImpl extends RouteFluentImpl> implements SubjectAccessReviewFluent.RouteContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final RouteBuilder builder;
    
            RouteContentNestedImpl(Route item){
                    this.builder = new RouteBuilder(this, item);
            }
            RouteContentNestedImpl(){
                    this.builder = new RouteBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withRouteContent(builder.build());
    }
    public N endRouteContent(){
            return and();
    }

}
    public class PolicyBindingContentNestedImpl extends PolicyBindingFluentImpl> implements SubjectAccessReviewFluent.PolicyBindingContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBindingBuilder builder;
    
            PolicyBindingContentNestedImpl(PolicyBinding item){
                    this.builder = new PolicyBindingBuilder(this, item);
            }
            PolicyBindingContentNestedImpl(){
                    this.builder = new PolicyBindingBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPolicyBindingContent(builder.build());
    }
    public N endPolicyBindingContent(){
            return and();
    }

}
    public class ResourceQuotaContentNestedImpl extends ResourceQuotaFluentImpl> implements SubjectAccessReviewFluent.ResourceQuotaContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaBuilder builder;
    
            ResourceQuotaContentNestedImpl(ResourceQuota item){
                    this.builder = new ResourceQuotaBuilder(this, item);
            }
            ResourceQuotaContentNestedImpl(){
                    this.builder = new ResourceQuotaBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withResourceQuotaContent(builder.build());
    }
    public N endResourceQuotaContent(){
            return and();
    }

}
    public class ServiceAccountContentNestedImpl extends ServiceAccountFluentImpl> implements SubjectAccessReviewFluent.ServiceAccountContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountBuilder builder;
    
            ServiceAccountContentNestedImpl(ServiceAccount item){
                    this.builder = new ServiceAccountBuilder(this, item);
            }
            ServiceAccountContentNestedImpl(){
                    this.builder = new ServiceAccountBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withServiceAccountContent(builder.build());
    }
    public N endServiceAccountContent(){
            return and();
    }

}
    public class ConfigMapContentNestedImpl extends ConfigMapFluentImpl> implements SubjectAccessReviewFluent.ConfigMapContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapBuilder builder;
    
            ConfigMapContentNestedImpl(ConfigMap item){
                    this.builder = new ConfigMapBuilder(this, item);
            }
            ConfigMapContentNestedImpl(){
                    this.builder = new ConfigMapBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withConfigMapContent(builder.build());
    }
    public N endConfigMapContent(){
            return and();
    }

}
    public class OAuthClientAuthorizationContentNestedImpl extends OAuthClientAuthorizationFluentImpl> implements SubjectAccessReviewFluent.OAuthClientAuthorizationContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientAuthorizationBuilder builder;
    
            OAuthClientAuthorizationContentNestedImpl(OAuthClientAuthorization item){
                    this.builder = new OAuthClientAuthorizationBuilder(this, item);
            }
            OAuthClientAuthorizationContentNestedImpl(){
                    this.builder = new OAuthClientAuthorizationBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withOAuthClientAuthorizationContent(builder.build());
    }
    public N endOAuthClientAuthorizationContent(){
            return and();
    }

}
    public class PolicyContentNestedImpl extends PolicyFluentImpl> implements SubjectAccessReviewFluent.PolicyContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBuilder builder;
    
            PolicyContentNestedImpl(Policy item){
                    this.builder = new PolicyBuilder(this, item);
            }
            PolicyContentNestedImpl(){
                    this.builder = new PolicyBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPolicyContent(builder.build());
    }
    public N endPolicyContent(){
            return and();
    }

}
    public class OAuthAuthorizeTokenContentNestedImpl extends OAuthAuthorizeTokenFluentImpl> implements SubjectAccessReviewFluent.OAuthAuthorizeTokenContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAuthorizeTokenBuilder builder;
    
            OAuthAuthorizeTokenContentNestedImpl(OAuthAuthorizeToken item){
                    this.builder = new OAuthAuthorizeTokenBuilder(this, item);
            }
            OAuthAuthorizeTokenContentNestedImpl(){
                    this.builder = new OAuthAuthorizeTokenBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withOAuthAuthorizeTokenContent(builder.build());
    }
    public N endOAuthAuthorizeTokenContent(){
            return and();
    }

}
    public class JenkinsBindingContentNestedImpl extends JenkinsBindingFluentImpl> implements SubjectAccessReviewFluent.JenkinsBindingContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingBuilder builder;
    
            JenkinsBindingContentNestedImpl(JenkinsBinding item){
                    this.builder = new JenkinsBindingBuilder(this, item);
            }
            JenkinsBindingContentNestedImpl(){
                    this.builder = new JenkinsBindingBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withJenkinsBindingContent(builder.build());
    }
    public N endJenkinsBindingContent(){
            return and();
    }

}
    public class IdentityContentNestedImpl extends IdentityFluentImpl> implements SubjectAccessReviewFluent.IdentityContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final IdentityBuilder builder;
    
            IdentityContentNestedImpl(Identity item){
                    this.builder = new IdentityBuilder(this, item);
            }
            IdentityContentNestedImpl(){
                    this.builder = new IdentityBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withIdentityContent(builder.build());
    }
    public N endIdentityContent(){
            return and();
    }

}
    public class PodTemplateContentNestedImpl extends PodTemplateFluentImpl> implements SubjectAccessReviewFluent.PodTemplateContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateBuilder builder;
    
            PodTemplateContentNestedImpl(PodTemplate item){
                    this.builder = new PodTemplateBuilder(this, item);
            }
            PodTemplateContentNestedImpl(){
                    this.builder = new PodTemplateBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPodTemplateContent(builder.build());
    }
    public N endPodTemplateContent(){
            return and();
    }

}
    public class TokenReviewContentNestedImpl extends TokenReviewFluentImpl> implements SubjectAccessReviewFluent.TokenReviewContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewBuilder builder;
    
            TokenReviewContentNestedImpl(TokenReview item){
                    this.builder = new TokenReviewBuilder(this, item);
            }
            TokenReviewContentNestedImpl(){
                    this.builder = new TokenReviewBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withTokenReviewContent(builder.build());
    }
    public N endTokenReviewContent(){
            return and();
    }

}
    public class CustomResourceDefinitionContentNestedImpl extends CustomResourceDefinitionFluentImpl> implements SubjectAccessReviewFluent.CustomResourceDefinitionContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionBuilder builder;
    
            CustomResourceDefinitionContentNestedImpl(CustomResourceDefinition item){
                    this.builder = new CustomResourceDefinitionBuilder(this, item);
            }
            CustomResourceDefinitionContentNestedImpl(){
                    this.builder = new CustomResourceDefinitionBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withCustomResourceDefinitionContent(builder.build());
    }
    public N endCustomResourceDefinitionContent(){
            return and();
    }

}
    public class ImageSignatureContentNestedImpl extends ImageSignatureFluentImpl> implements SubjectAccessReviewFluent.ImageSignatureContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageSignatureBuilder builder;
    
            ImageSignatureContentNestedImpl(ImageSignature item){
                    this.builder = new ImageSignatureBuilder(this, item);
            }
            ImageSignatureContentNestedImpl(){
                    this.builder = new ImageSignatureBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withImageSignatureContent(builder.build());
    }
    public N endImageSignatureContent(){
            return and();
    }

}
    public class ClusterRoleContentNestedImpl extends ClusterRoleFluentImpl> implements SubjectAccessReviewFluent.ClusterRoleContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterRoleBuilder builder;
    
            ClusterRoleContentNestedImpl(ClusterRole item){
                    this.builder = new ClusterRoleBuilder(this, item);
            }
            ClusterRoleContentNestedImpl(){
                    this.builder = new ClusterRoleBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withClusterRoleContent(builder.build());
    }
    public N endClusterRoleContent(){
            return and();
    }

}
    public class NamespaceContentNestedImpl extends NamespaceFluentImpl> implements SubjectAccessReviewFluent.NamespaceContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceBuilder builder;
    
            NamespaceContentNestedImpl(Namespace item){
                    this.builder = new NamespaceBuilder(this, item);
            }
            NamespaceContentNestedImpl(){
                    this.builder = new NamespaceBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withNamespaceContent(builder.build());
    }
    public N endNamespaceContent(){
            return and();
    }

}
    public class ClusterPolicyContentNestedImpl extends ClusterPolicyFluentImpl> implements SubjectAccessReviewFluent.ClusterPolicyContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBuilder builder;
    
            ClusterPolicyContentNestedImpl(ClusterPolicy item){
                    this.builder = new ClusterPolicyBuilder(this, item);
            }
            ClusterPolicyContentNestedImpl(){
                    this.builder = new ClusterPolicyBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withClusterPolicyContent(builder.build());
    }
    public N endClusterPolicyContent(){
            return and();
    }

}
    public class BuildContentNestedImpl extends BuildFluentImpl> implements SubjectAccessReviewFluent.BuildContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildBuilder builder;
    
            BuildContentNestedImpl(Build item){
                    this.builder = new BuildBuilder(this, item);
            }
            BuildContentNestedImpl(){
                    this.builder = new BuildBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withBuildContent(builder.build());
    }
    public N endBuildContent(){
            return and();
    }

}
    public class ScaleContentNestedImpl extends ScaleFluentImpl> implements SubjectAccessReviewFluent.ScaleContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleBuilder builder;
    
            ScaleContentNestedImpl(Scale item){
                    this.builder = new ScaleBuilder(this, item);
            }
            ScaleContentNestedImpl(){
                    this.builder = new ScaleBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withScaleContent(builder.build());
    }
    public N endScaleContent(){
            return and();
    }

}
    public class PodContentNestedImpl extends PodFluentImpl> implements SubjectAccessReviewFluent.PodContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodBuilder builder;
    
            PodContentNestedImpl(Pod item){
                    this.builder = new PodBuilder(this, item);
            }
            PodContentNestedImpl(){
                    this.builder = new PodBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPodContent(builder.build());
    }
    public N endPodContent(){
            return and();
    }

}
    public class HorizontalPodAutoscalerContentNestedImpl extends HorizontalPodAutoscalerFluentImpl> implements SubjectAccessReviewFluent.HorizontalPodAutoscalerContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerBuilder builder;
    
            HorizontalPodAutoscalerContentNestedImpl(HorizontalPodAutoscaler item){
                    this.builder = new HorizontalPodAutoscalerBuilder(this, item);
            }
            HorizontalPodAutoscalerContentNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withHorizontalPodAutoscalerContent(builder.build());
    }
    public N endHorizontalPodAutoscalerContent(){
            return and();
    }

}
    public class ThirdPartyResourceContentNestedImpl extends ThirdPartyResourceFluentImpl> implements SubjectAccessReviewFluent.ThirdPartyResourceContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceBuilder builder;
    
            ThirdPartyResourceContentNestedImpl(ThirdPartyResource item){
                    this.builder = new ThirdPartyResourceBuilder(this, item);
            }
            ThirdPartyResourceContentNestedImpl(){
                    this.builder = new ThirdPartyResourceBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withThirdPartyResourceContent(builder.build());
    }
    public N endThirdPartyResourceContent(){
            return and();
    }

}
    public class ImageStreamTagContentNestedImpl extends ImageStreamTagFluentImpl> implements SubjectAccessReviewFluent.ImageStreamTagContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageStreamTagBuilder builder;
    
            ImageStreamTagContentNestedImpl(ImageStreamTag item){
                    this.builder = new ImageStreamTagBuilder(this, item);
            }
            ImageStreamTagContentNestedImpl(){
                    this.builder = new ImageStreamTagBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withImageStreamTagContent(builder.build());
    }
    public N endImageStreamTagContent(){
            return and();
    }

}
    public class ComponentStatusContentNestedImpl extends ComponentStatusFluentImpl> implements SubjectAccessReviewFluent.ComponentStatusContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentStatusBuilder builder;
    
            ComponentStatusContentNestedImpl(ComponentStatus item){
                    this.builder = new ComponentStatusBuilder(this, item);
            }
            ComponentStatusContentNestedImpl(){
                    this.builder = new ComponentStatusBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withComponentStatusContent(builder.build());
    }
    public N endComponentStatusContent(){
            return and();
    }

}
    public class SecretContentNestedImpl extends SecretFluentImpl> implements SubjectAccessReviewFluent.SecretContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretBuilder builder;
    
            SecretContentNestedImpl(Secret item){
                    this.builder = new SecretBuilder(this, item);
            }
            SecretContentNestedImpl(){
                    this.builder = new SecretBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withSecretContent(builder.build());
    }
    public N endSecretContent(){
            return and();
    }

}
    public class ReplicationControllerContentNestedImpl extends ReplicationControllerFluentImpl> implements SubjectAccessReviewFluent.ReplicationControllerContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerBuilder builder;
    
            ReplicationControllerContentNestedImpl(ReplicationController item){
                    this.builder = new ReplicationControllerBuilder(this, item);
            }
            ReplicationControllerContentNestedImpl(){
                    this.builder = new ReplicationControllerBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withReplicationControllerContent(builder.build());
    }
    public N endReplicationControllerContent(){
            return and();
    }

}
    public class LimitRangeContentNestedImpl extends LimitRangeFluentImpl> implements SubjectAccessReviewFluent.LimitRangeContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeBuilder builder;
    
            LimitRangeContentNestedImpl(LimitRange item){
                    this.builder = new LimitRangeBuilder(this, item);
            }
            LimitRangeContentNestedImpl(){
                    this.builder = new LimitRangeBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withLimitRangeContent(builder.build());
    }
    public N endLimitRangeContent(){
            return and();
    }

}
    public class EndpointsContentNestedImpl extends EndpointsFluentImpl> implements SubjectAccessReviewFluent.EndpointsContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsBuilder builder;
    
            EndpointsContentNestedImpl(Endpoints item){
                    this.builder = new EndpointsBuilder(this, item);
            }
            EndpointsContentNestedImpl(){
                    this.builder = new EndpointsBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withEndpointsContent(builder.build());
    }
    public N endEndpointsContent(){
            return and();
    }

}
    public class SecurityContextConstraintsContentNestedImpl extends SecurityContextConstraintsFluentImpl> implements SubjectAccessReviewFluent.SecurityContextConstraintsContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecurityContextConstraintsBuilder builder;
    
            SecurityContextConstraintsContentNestedImpl(SecurityContextConstraints item){
                    this.builder = new SecurityContextConstraintsBuilder(this, item);
            }
            SecurityContextConstraintsContentNestedImpl(){
                    this.builder = new SecurityContextConstraintsBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withSecurityContextConstraintsContent(builder.build());
    }
    public N endSecurityContextConstraintsContent(){
            return and();
    }

}
    public class GroupContentNestedImpl extends GroupFluentImpl> implements SubjectAccessReviewFluent.GroupContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final GroupBuilder builder;
    
            GroupContentNestedImpl(Group item){
                    this.builder = new GroupBuilder(this, item);
            }
            GroupContentNestedImpl(){
                    this.builder = new GroupBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withGroupContent(builder.build());
    }
    public N endGroupContent(){
            return and();
    }

}
    public class EventContentNestedImpl extends EventFluentImpl> implements SubjectAccessReviewFluent.EventContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventBuilder builder;
    
            EventContentNestedImpl(Event item){
                    this.builder = new EventBuilder(this, item);
            }
            EventContentNestedImpl(){
                    this.builder = new EventBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withEventContent(builder.build());
    }
    public N endEventContent(){
            return and();
    }

}
    public class NodeContentNestedImpl extends NodeFluentImpl> implements SubjectAccessReviewFluent.NodeContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeBuilder builder;
    
            NodeContentNestedImpl(Node item){
                    this.builder = new NodeBuilder(this, item);
            }
            NodeContentNestedImpl(){
                    this.builder = new NodeBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withNodeContent(builder.build());
    }
    public N endNodeContent(){
            return and();
    }

}
    public class ReplicaSetContentNestedImpl extends ReplicaSetFluentImpl> implements SubjectAccessReviewFluent.ReplicaSetContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetBuilder builder;
    
            ReplicaSetContentNestedImpl(ReplicaSet item){
                    this.builder = new ReplicaSetBuilder(this, item);
            }
            ReplicaSetContentNestedImpl(){
                    this.builder = new ReplicaSetBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withReplicaSetContent(builder.build());
    }
    public N endReplicaSetContent(){
            return and();
    }

}
    public class ClusterRoleBindingContentNestedImpl extends ClusterRoleBindingFluentImpl> implements SubjectAccessReviewFluent.ClusterRoleBindingContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterRoleBindingBuilder builder;
    
            ClusterRoleBindingContentNestedImpl(ClusterRoleBinding item){
                    this.builder = new ClusterRoleBindingBuilder(this, item);
            }
            ClusterRoleBindingContentNestedImpl(){
                    this.builder = new ClusterRoleBindingBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withClusterRoleBindingContent(builder.build());
    }
    public N endClusterRoleBindingContent(){
            return and();
    }

}
    public class JenkinsContentNestedImpl extends JenkinsFluentImpl> implements SubjectAccessReviewFluent.JenkinsContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBuilder builder;
    
            JenkinsContentNestedImpl(Jenkins item){
                    this.builder = new JenkinsBuilder(this, item);
            }
            JenkinsContentNestedImpl(){
                    this.builder = new JenkinsBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withJenkinsContent(builder.build());
    }
    public N endJenkinsContent(){
            return and();
    }

}
    public class DaemonSetContentNestedImpl extends DaemonSetFluentImpl> implements SubjectAccessReviewFluent.DaemonSetContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetBuilder builder;
    
            DaemonSetContentNestedImpl(DaemonSet item){
                    this.builder = new DaemonSetBuilder(this, item);
            }
            DaemonSetContentNestedImpl(){
                    this.builder = new DaemonSetBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withDaemonSetContent(builder.build());
    }
    public N endDaemonSetContent(){
            return and();
    }

}
    public class PodDisruptionBudgetContentNestedImpl extends PodDisruptionBudgetFluentImpl> implements SubjectAccessReviewFluent.PodDisruptionBudgetContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetBuilder builder;
    
            PodDisruptionBudgetContentNestedImpl(PodDisruptionBudget item){
                    this.builder = new PodDisruptionBudgetBuilder(this, item);
            }
            PodDisruptionBudgetContentNestedImpl(){
                    this.builder = new PodDisruptionBudgetBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPodDisruptionBudgetContent(builder.build());
    }
    public N endPodDisruptionBudgetContent(){
            return and();
    }

}
    public class ImageStreamContentNestedImpl extends ImageStreamFluentImpl> implements SubjectAccessReviewFluent.ImageStreamContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageStreamBuilder builder;
    
            ImageStreamContentNestedImpl(ImageStream item){
                    this.builder = new ImageStreamBuilder(this, item);
            }
            ImageStreamContentNestedImpl(){
                    this.builder = new ImageStreamBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withImageStreamContent(builder.build());
    }
    public N endImageStreamContent(){
            return and();
    }

}
    public class RoleBindingRestrictionContentNestedImpl extends RoleBindingRestrictionFluentImpl> implements SubjectAccessReviewFluent.RoleBindingRestrictionContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingRestrictionBuilder builder;
    
            RoleBindingRestrictionContentNestedImpl(RoleBindingRestriction item){
                    this.builder = new RoleBindingRestrictionBuilder(this, item);
            }
            RoleBindingRestrictionContentNestedImpl(){
                    this.builder = new RoleBindingRestrictionBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withRoleBindingRestrictionContent(builder.build());
    }
    public N endRoleBindingRestrictionContent(){
            return and();
    }

}
    public class BindingContentNestedImpl extends BindingFluentImpl> implements SubjectAccessReviewFluent.BindingContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final BindingBuilder builder;
    
            BindingContentNestedImpl(Binding item){
                    this.builder = new BindingBuilder(this, item);
            }
            BindingContentNestedImpl(){
                    this.builder = new BindingBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withBindingContent(builder.build());
    }
    public N endBindingContent(){
            return and();
    }

}
    public class AuthorizationLocalSubjectAccessReviewContentNestedImpl extends io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewFluentImpl> implements SubjectAccessReviewFluent.AuthorizationLocalSubjectAccessReviewContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder builder;
    
            AuthorizationLocalSubjectAccessReviewContentNestedImpl(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(this, item);
            }
            AuthorizationLocalSubjectAccessReviewContentNestedImpl(){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withLocalSubjectAccessReviewContent(builder.build());
    }
    public N endAuthorizationLocalSubjectAccessReviewContent(){
            return and();
    }

}
    public class StatefulSetContentNestedImpl extends StatefulSetFluentImpl> implements SubjectAccessReviewFluent.StatefulSetContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetBuilder builder;
    
            StatefulSetContentNestedImpl(StatefulSet item){
                    this.builder = new StatefulSetBuilder(this, item);
            }
            StatefulSetContentNestedImpl(){
                    this.builder = new StatefulSetBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withStatefulSetContent(builder.build());
    }
    public N endStatefulSetContent(){
            return and();
    }

}
    public class PipelineTemplateTaskInstanceContentNestedImpl extends PipelineTemplateTaskInstanceFluentImpl> implements SubjectAccessReviewFluent.PipelineTemplateTaskInstanceContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateTaskInstanceBuilder builder;
    
            PipelineTemplateTaskInstanceContentNestedImpl(PipelineTemplateTaskInstance item){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this, item);
            }
            PipelineTemplateTaskInstanceContentNestedImpl(){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPipelineTemplateTaskInstanceContent(builder.build());
    }
    public N endPipelineTemplateTaskInstanceContent(){
            return and();
    }

}
    public class OAuthClientContentNestedImpl extends OAuthClientFluentImpl> implements SubjectAccessReviewFluent.OAuthClientContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientBuilder builder;
    
            OAuthClientContentNestedImpl(OAuthClient item){
                    this.builder = new OAuthClientBuilder(this, item);
            }
            OAuthClientContentNestedImpl(){
                    this.builder = new OAuthClientBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withOAuthClientContent(builder.build());
    }
    public N endOAuthClientContent(){
            return and();
    }

}
    public class TemplateContentNestedImpl extends TemplateFluentImpl> implements SubjectAccessReviewFluent.TemplateContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final TemplateBuilder builder;
    
            TemplateContentNestedImpl(Template item){
                    this.builder = new TemplateBuilder(this, item);
            }
            TemplateContentNestedImpl(){
                    this.builder = new TemplateBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withTemplateContent(builder.build());
    }
    public N endTemplateContent(){
            return and();
    }

}
    public class BuildConfigContentNestedImpl extends BuildConfigFluentImpl> implements SubjectAccessReviewFluent.BuildConfigContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildConfigBuilder builder;
    
            BuildConfigContentNestedImpl(BuildConfig item){
                    this.builder = new BuildConfigBuilder(this, item);
            }
            BuildConfigContentNestedImpl(){
                    this.builder = new BuildConfigBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withBuildConfigContent(builder.build());
    }
    public N endBuildConfigContent(){
            return and();
    }

}
    public class PodSecurityPolicyContentNestedImpl extends PodSecurityPolicyFluentImpl> implements SubjectAccessReviewFluent.PodSecurityPolicyContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyBuilder builder;
    
            PodSecurityPolicyContentNestedImpl(PodSecurityPolicy item){
                    this.builder = new PodSecurityPolicyBuilder(this, item);
            }
            PodSecurityPolicyContentNestedImpl(){
                    this.builder = new PodSecurityPolicyBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPodSecurityPolicyContent(builder.build());
    }
    public N endPodSecurityPolicyContent(){
            return and();
    }

}
    public class PipelineContentNestedImpl extends PipelineFluentImpl> implements SubjectAccessReviewFluent.PipelineContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineBuilder builder;
    
            PipelineContentNestedImpl(Pipeline item){
                    this.builder = new PipelineBuilder(this, item);
            }
            PipelineContentNestedImpl(){
                    this.builder = new PipelineBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPipelineContent(builder.build());
    }
    public N endPipelineContent(){
            return and();
    }

}
    public class RoleContentNestedImpl extends RoleFluentImpl> implements SubjectAccessReviewFluent.RoleContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBuilder builder;
    
            RoleContentNestedImpl(Role item){
                    this.builder = new RoleBuilder(this, item);
            }
            RoleContentNestedImpl(){
                    this.builder = new RoleBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withRoleContent(builder.build());
    }
    public N endRoleContent(){
            return and();
    }

}
    public class CronJobContentNestedImpl extends CronJobFluentImpl> implements SubjectAccessReviewFluent.CronJobContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobBuilder builder;
    
            CronJobContentNestedImpl(CronJob item){
                    this.builder = new CronJobBuilder(this, item);
            }
            CronJobContentNestedImpl(){
                    this.builder = new CronJobBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withCronJobContent(builder.build());
    }
    public N endCronJobContent(){
            return and();
    }

}
    public class UserContentNestedImpl extends UserFluentImpl> implements SubjectAccessReviewFluent.UserContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final UserBuilder builder;
    
            UserContentNestedImpl(User item){
                    this.builder = new UserBuilder(this, item);
            }
            UserContentNestedImpl(){
                    this.builder = new UserBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withUserContent(builder.build());
    }
    public N endUserContent(){
            return and();
    }

}
    public class StorageClassContentNestedImpl extends StorageClassFluentImpl> implements SubjectAccessReviewFluent.StorageClassContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassBuilder builder;
    
            StorageClassContentNestedImpl(StorageClass item){
                    this.builder = new StorageClassBuilder(this, item);
            }
            StorageClassContentNestedImpl(){
                    this.builder = new StorageClassBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withStorageClassContent(builder.build());
    }
    public N endStorageClassContent(){
            return and();
    }

}
    public class PipelineConfigTemplateContentNestedImpl extends PipelineConfigTemplateFluentImpl> implements SubjectAccessReviewFluent.PipelineConfigTemplateContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigTemplateBuilder builder;
    
            PipelineConfigTemplateContentNestedImpl(PipelineConfigTemplate item){
                    this.builder = new PipelineConfigTemplateBuilder(this, item);
            }
            PipelineConfigTemplateContentNestedImpl(){
                    this.builder = new PipelineConfigTemplateBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPipelineConfigTemplateContent(builder.build());
    }
    public N endPipelineConfigTemplateContent(){
            return and();
    }

}
    public class PipelineConfigContentNestedImpl extends PipelineConfigFluentImpl> implements SubjectAccessReviewFluent.PipelineConfigContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigBuilder builder;
    
            PipelineConfigContentNestedImpl(PipelineConfig item){
                    this.builder = new PipelineConfigBuilder(this, item);
            }
            PipelineConfigContentNestedImpl(){
                    this.builder = new PipelineConfigBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPipelineConfigContent(builder.build());
    }
    public N endPipelineConfigContent(){
            return and();
    }

}
    public class DeploymentConfigContentNestedImpl extends DeploymentConfigFluentImpl> implements SubjectAccessReviewFluent.DeploymentConfigContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentConfigBuilder builder;
    
            DeploymentConfigContentNestedImpl(DeploymentConfig item){
                    this.builder = new DeploymentConfigBuilder(this, item);
            }
            DeploymentConfigContentNestedImpl(){
                    this.builder = new DeploymentConfigBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withDeploymentConfigContent(builder.build());
    }
    public N endDeploymentConfigContent(){
            return and();
    }

}
    public class OAuthAccessTokenContentNestedImpl extends OAuthAccessTokenFluentImpl> implements SubjectAccessReviewFluent.OAuthAccessTokenContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAccessTokenBuilder builder;
    
            OAuthAccessTokenContentNestedImpl(OAuthAccessToken item){
                    this.builder = new OAuthAccessTokenBuilder(this, item);
            }
            OAuthAccessTokenContentNestedImpl(){
                    this.builder = new OAuthAccessTokenBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withOAuthAccessTokenContent(builder.build());
    }
    public N endOAuthAccessTokenContent(){
            return and();
    }

}
    public class PersistentVolumeClaimContentNestedImpl extends PersistentVolumeClaimFluentImpl> implements SubjectAccessReviewFluent.PersistentVolumeClaimContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimBuilder builder;
    
            PersistentVolumeClaimContentNestedImpl(PersistentVolumeClaim item){
                    this.builder = new PersistentVolumeClaimBuilder(this, item);
            }
            PersistentVolumeClaimContentNestedImpl(){
                    this.builder = new PersistentVolumeClaimBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPersistentVolumeClaimContent(builder.build());
    }
    public N endPersistentVolumeClaimContent(){
            return and();
    }

}
    public class NetworkPolicyContentNestedImpl extends NetworkPolicyFluentImpl> implements SubjectAccessReviewFluent.NetworkPolicyContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyBuilder builder;
    
            NetworkPolicyContentNestedImpl(NetworkPolicy item){
                    this.builder = new NetworkPolicyBuilder(this, item);
            }
            NetworkPolicyContentNestedImpl(){
                    this.builder = new NetworkPolicyBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withNetworkPolicyContent(builder.build());
    }
    public N endNetworkPolicyContent(){
            return and();
    }

}
    public class ImageContentNestedImpl extends ImageFluentImpl> implements SubjectAccessReviewFluent.ImageContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageBuilder builder;
    
            ImageContentNestedImpl(Image item){
                    this.builder = new ImageBuilder(this, item);
            }
            ImageContentNestedImpl(){
                    this.builder = new ImageBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withImageContent(builder.build());
    }
    public N endImageContent(){
            return and();
    }

}
    public class ServiceContentNestedImpl extends ServiceFluentImpl> implements SubjectAccessReviewFluent.ServiceContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceBuilder builder;
    
            ServiceContentNestedImpl(Service item){
                    this.builder = new ServiceBuilder(this, item);
            }
            ServiceContentNestedImpl(){
                    this.builder = new ServiceBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withServiceContent(builder.build());
    }
    public N endServiceContent(){
            return and();
    }

}
    public class JobContentNestedImpl extends JobFluentImpl> implements SubjectAccessReviewFluent.JobContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobBuilder builder;
    
            JobContentNestedImpl(Job item){
                    this.builder = new JobBuilder(this, item);
            }
            JobContentNestedImpl(){
                    this.builder = new JobBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withJobContent(builder.build());
    }
    public N endJobContent(){
            return and();
    }

}
    public class DeploymentContentNestedImpl extends DeploymentFluentImpl> implements SubjectAccessReviewFluent.DeploymentContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentBuilder builder;
    
            DeploymentContentNestedImpl(Deployment item){
                    this.builder = new DeploymentBuilder(this, item);
            }
            DeploymentContentNestedImpl(){
                    this.builder = new DeploymentBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withDeploymentContent(builder.build());
    }
    public N endDeploymentContent(){
            return and();
    }

}
    public class ClusterPolicyBindingContentNestedImpl extends ClusterPolicyBindingFluentImpl> implements SubjectAccessReviewFluent.ClusterPolicyBindingContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBindingBuilder builder;
    
            ClusterPolicyBindingContentNestedImpl(ClusterPolicyBinding item){
                    this.builder = new ClusterPolicyBindingBuilder(this, item);
            }
            ClusterPolicyBindingContentNestedImpl(){
                    this.builder = new ClusterPolicyBindingBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withClusterPolicyBindingContent(builder.build());
    }
    public N endClusterPolicyBindingContent(){
            return and();
    }

}
    public class ProjectContentNestedImpl extends ProjectFluentImpl> implements SubjectAccessReviewFluent.ProjectContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectBuilder builder;
    
            ProjectContentNestedImpl(Project item){
                    this.builder = new ProjectBuilder(this, item);
            }
            ProjectContentNestedImpl(){
                    this.builder = new ProjectBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withProjectContent(builder.build());
    }
    public N endProjectContent(){
            return and();
    }

}
    public class BuildRequestContentNestedImpl extends BuildRequestFluentImpl> implements SubjectAccessReviewFluent.BuildRequestContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildRequestBuilder builder;
    
            BuildRequestContentNestedImpl(BuildRequest item){
                    this.builder = new BuildRequestBuilder(this, item);
            }
            BuildRequestContentNestedImpl(){
                    this.builder = new BuildRequestBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withBuildRequestContent(builder.build());
    }
    public N endBuildRequestContent(){
            return and();
    }

}
    public class RoleBindingContentNestedImpl extends RoleBindingFluentImpl> implements SubjectAccessReviewFluent.RoleBindingContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingBuilder builder;
    
            RoleBindingContentNestedImpl(RoleBinding item){
                    this.builder = new RoleBindingBuilder(this, item);
            }
            RoleBindingContentNestedImpl(){
                    this.builder = new RoleBindingBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withRoleBindingContent(builder.build());
    }
    public N endRoleBindingContent(){
            return and();
    }

}
    public class PersistentVolumeContentNestedImpl extends PersistentVolumeFluentImpl> implements SubjectAccessReviewFluent.PersistentVolumeContentNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeBuilder builder;
    
            PersistentVolumeContentNestedImpl(PersistentVolume item){
                    this.builder = new PersistentVolumeBuilder(this, item);
            }
            PersistentVolumeContentNestedImpl(){
                    this.builder = new PersistentVolumeBuilder(this);
            }
    
    public N and(){
            return (N) SubjectAccessReviewFluentImpl.this.withPersistentVolumeContent(builder.build());
    }
    public N endPersistentVolumeContent(){
            return and();
    }

}


}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy