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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of kubernetes-model Show documentation
There is a newer version: 0.2.12
package io.alauda.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.authorization.SubjectAccessReviewBuilder;
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.authorization.SubjectAccessReview;
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.authorization.SubjectAccessReviewFluentImpl;
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 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 PolicyRuleFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements PolicyRuleFluent{

    private List apiGroups = new ArrayList();
    private VisitableBuilder attributeRestrictions;
    private List nonResourceURLs = new ArrayList();
    private List resourceNames = new ArrayList();
    private List resources = new ArrayList();
    private List verbs = new ArrayList();

    public PolicyRuleFluentImpl(){
    }
    public PolicyRuleFluentImpl(PolicyRule instance){
            this.withApiGroups(instance.getApiGroups()); 
            this.withAttributeRestrictions(instance.getAttributeRestrictions()); 
            this.withNonResourceURLs(instance.getNonResourceURLs()); 
            this.withResourceNames(instance.getResourceNames()); 
            this.withResources(instance.getResources()); 
            this.withVerbs(instance.getVerbs()); 
    }

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

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

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

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

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

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

    public List getApiGroups(){
            return this.apiGroups;
    }

    public String getApiGroup(int index){
            return this.apiGroups.get(index);
    }

    public String getFirstApiGroup(){
            return this.apiGroups.get(0);
    }

    public String getLastApiGroup(){
            return this.apiGroups.get(apiGroups.size() - 1);
    }

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

    public A withApiGroups(List apiGroups){
            this.apiGroups.clear();
            if (apiGroups != null) {for (String item : apiGroups){this.addToApiGroups(item);}} return (A) this;
    }

    public A withApiGroups(String... apiGroups){
            this.apiGroups.clear(); if (apiGroups != null) {for (String item :apiGroups){ this.addToApiGroups(item);}} return (A) this;
    }

    public Boolean hasApiGroups(){
            return apiGroups!= null && !apiGroups.isEmpty();
    }

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

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

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

    public Boolean hasAttributeRestrictions(){
            return this.attributeRestrictions!=null;
    }

    public A withIngressAttributeRestrictions(Ingress ingressAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (ingressAttributeRestrictions!=null){ this.attributeRestrictions= new IngressBuilder(ingressAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.IngressAttributeRestrictionsNested withNewIngressAttributeRestrictions(){
            return new IngressAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.IngressAttributeRestrictionsNested withNewIngressAttributeRestrictionsLike(Ingress item){
            return new IngressAttributeRestrictionsNestedImpl(item);
    }

    public A withRouteAttributeRestrictions(Route routeAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (routeAttributeRestrictions!=null){ this.attributeRestrictions= new RouteBuilder(routeAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.RouteAttributeRestrictionsNested withNewRouteAttributeRestrictions(){
            return new RouteAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.RouteAttributeRestrictionsNested withNewRouteAttributeRestrictionsLike(Route item){
            return new RouteAttributeRestrictionsNestedImpl(item);
    }

    public A withPolicyBindingAttributeRestrictions(PolicyBinding policyBindingAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (policyBindingAttributeRestrictions!=null){ this.attributeRestrictions= new PolicyBindingBuilder(policyBindingAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PolicyBindingAttributeRestrictionsNested withNewPolicyBindingAttributeRestrictions(){
            return new PolicyBindingAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PolicyBindingAttributeRestrictionsNested withNewPolicyBindingAttributeRestrictionsLike(PolicyBinding item){
            return new PolicyBindingAttributeRestrictionsNestedImpl(item);
    }

    public A withResourceQuotaAttributeRestrictions(ResourceQuota resourceQuotaAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (resourceQuotaAttributeRestrictions!=null){ this.attributeRestrictions= new ResourceQuotaBuilder(resourceQuotaAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ResourceQuotaAttributeRestrictionsNested withNewResourceQuotaAttributeRestrictions(){
            return new ResourceQuotaAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ResourceQuotaAttributeRestrictionsNested withNewResourceQuotaAttributeRestrictionsLike(ResourceQuota item){
            return new ResourceQuotaAttributeRestrictionsNestedImpl(item);
    }

    public A withServiceAccountAttributeRestrictions(ServiceAccount serviceAccountAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (serviceAccountAttributeRestrictions!=null){ this.attributeRestrictions= new ServiceAccountBuilder(serviceAccountAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ServiceAccountAttributeRestrictionsNested withNewServiceAccountAttributeRestrictions(){
            return new ServiceAccountAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ServiceAccountAttributeRestrictionsNested withNewServiceAccountAttributeRestrictionsLike(ServiceAccount item){
            return new ServiceAccountAttributeRestrictionsNestedImpl(item);
    }

    public A withConfigMapAttributeRestrictions(ConfigMap configMapAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (configMapAttributeRestrictions!=null){ this.attributeRestrictions= new ConfigMapBuilder(configMapAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ConfigMapAttributeRestrictionsNested withNewConfigMapAttributeRestrictions(){
            return new ConfigMapAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ConfigMapAttributeRestrictionsNested withNewConfigMapAttributeRestrictionsLike(ConfigMap item){
            return new ConfigMapAttributeRestrictionsNestedImpl(item);
    }

    public A withOAuthClientAuthorizationAttributeRestrictions(OAuthClientAuthorization oAuthClientAuthorizationAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (oAuthClientAuthorizationAttributeRestrictions!=null){ this.attributeRestrictions= new OAuthClientAuthorizationBuilder(oAuthClientAuthorizationAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.OAuthClientAuthorizationAttributeRestrictionsNested withNewOAuthClientAuthorizationAttributeRestrictions(){
            return new OAuthClientAuthorizationAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.OAuthClientAuthorizationAttributeRestrictionsNested withNewOAuthClientAuthorizationAttributeRestrictionsLike(OAuthClientAuthorization item){
            return new OAuthClientAuthorizationAttributeRestrictionsNestedImpl(item);
    }

    public A withPolicyAttributeRestrictions(Policy policyAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (policyAttributeRestrictions!=null){ this.attributeRestrictions= new PolicyBuilder(policyAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PolicyAttributeRestrictionsNested withNewPolicyAttributeRestrictions(){
            return new PolicyAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PolicyAttributeRestrictionsNested withNewPolicyAttributeRestrictionsLike(Policy item){
            return new PolicyAttributeRestrictionsNestedImpl(item);
    }

    public A withOAuthAuthorizeTokenAttributeRestrictions(OAuthAuthorizeToken oAuthAuthorizeTokenAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (oAuthAuthorizeTokenAttributeRestrictions!=null){ this.attributeRestrictions= new OAuthAuthorizeTokenBuilder(oAuthAuthorizeTokenAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.OAuthAuthorizeTokenAttributeRestrictionsNested withNewOAuthAuthorizeTokenAttributeRestrictions(){
            return new OAuthAuthorizeTokenAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.OAuthAuthorizeTokenAttributeRestrictionsNested withNewOAuthAuthorizeTokenAttributeRestrictionsLike(OAuthAuthorizeToken item){
            return new OAuthAuthorizeTokenAttributeRestrictionsNestedImpl(item);
    }

    public A withJenkinsBindingAttributeRestrictions(JenkinsBinding jenkinsBindingAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (jenkinsBindingAttributeRestrictions!=null){ this.attributeRestrictions= new JenkinsBindingBuilder(jenkinsBindingAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.JenkinsBindingAttributeRestrictionsNested withNewJenkinsBindingAttributeRestrictions(){
            return new JenkinsBindingAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.JenkinsBindingAttributeRestrictionsNested withNewJenkinsBindingAttributeRestrictionsLike(JenkinsBinding item){
            return new JenkinsBindingAttributeRestrictionsNestedImpl(item);
    }

    public A withIdentityAttributeRestrictions(Identity identityAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (identityAttributeRestrictions!=null){ this.attributeRestrictions= new IdentityBuilder(identityAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.IdentityAttributeRestrictionsNested withNewIdentityAttributeRestrictions(){
            return new IdentityAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.IdentityAttributeRestrictionsNested withNewIdentityAttributeRestrictionsLike(Identity item){
            return new IdentityAttributeRestrictionsNestedImpl(item);
    }

    public A withPodTemplateAttributeRestrictions(PodTemplate podTemplateAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (podTemplateAttributeRestrictions!=null){ this.attributeRestrictions= new PodTemplateBuilder(podTemplateAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PodTemplateAttributeRestrictionsNested withNewPodTemplateAttributeRestrictions(){
            return new PodTemplateAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PodTemplateAttributeRestrictionsNested withNewPodTemplateAttributeRestrictionsLike(PodTemplate item){
            return new PodTemplateAttributeRestrictionsNestedImpl(item);
    }

    public A withTokenReviewAttributeRestrictions(TokenReview tokenReviewAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (tokenReviewAttributeRestrictions!=null){ this.attributeRestrictions= new TokenReviewBuilder(tokenReviewAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.TokenReviewAttributeRestrictionsNested withNewTokenReviewAttributeRestrictions(){
            return new TokenReviewAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.TokenReviewAttributeRestrictionsNested withNewTokenReviewAttributeRestrictionsLike(TokenReview item){
            return new TokenReviewAttributeRestrictionsNestedImpl(item);
    }

    public A withCustomResourceDefinitionAttributeRestrictions(CustomResourceDefinition customResourceDefinitionAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (customResourceDefinitionAttributeRestrictions!=null){ this.attributeRestrictions= new CustomResourceDefinitionBuilder(customResourceDefinitionAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.CustomResourceDefinitionAttributeRestrictionsNested withNewCustomResourceDefinitionAttributeRestrictions(){
            return new CustomResourceDefinitionAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.CustomResourceDefinitionAttributeRestrictionsNested withNewCustomResourceDefinitionAttributeRestrictionsLike(CustomResourceDefinition item){
            return new CustomResourceDefinitionAttributeRestrictionsNestedImpl(item);
    }

    public A withImageSignatureAttributeRestrictions(ImageSignature imageSignatureAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (imageSignatureAttributeRestrictions!=null){ this.attributeRestrictions= new ImageSignatureBuilder(imageSignatureAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ImageSignatureAttributeRestrictionsNested withNewImageSignatureAttributeRestrictions(){
            return new ImageSignatureAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ImageSignatureAttributeRestrictionsNested withNewImageSignatureAttributeRestrictionsLike(ImageSignature item){
            return new ImageSignatureAttributeRestrictionsNestedImpl(item);
    }

    public A withClusterRoleAttributeRestrictions(ClusterRole clusterRoleAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (clusterRoleAttributeRestrictions!=null){ this.attributeRestrictions= new ClusterRoleBuilder(clusterRoleAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ClusterRoleAttributeRestrictionsNested withNewClusterRoleAttributeRestrictions(){
            return new ClusterRoleAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ClusterRoleAttributeRestrictionsNested withNewClusterRoleAttributeRestrictionsLike(ClusterRole item){
            return new ClusterRoleAttributeRestrictionsNestedImpl(item);
    }

    public A withNamespaceAttributeRestrictions(Namespace namespaceAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (namespaceAttributeRestrictions!=null){ this.attributeRestrictions= new NamespaceBuilder(namespaceAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.NamespaceAttributeRestrictionsNested withNewNamespaceAttributeRestrictions(){
            return new NamespaceAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.NamespaceAttributeRestrictionsNested withNewNamespaceAttributeRestrictionsLike(Namespace item){
            return new NamespaceAttributeRestrictionsNestedImpl(item);
    }

    public A withClusterPolicyAttributeRestrictions(ClusterPolicy clusterPolicyAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (clusterPolicyAttributeRestrictions!=null){ this.attributeRestrictions= new ClusterPolicyBuilder(clusterPolicyAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ClusterPolicyAttributeRestrictionsNested withNewClusterPolicyAttributeRestrictions(){
            return new ClusterPolicyAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ClusterPolicyAttributeRestrictionsNested withNewClusterPolicyAttributeRestrictionsLike(ClusterPolicy item){
            return new ClusterPolicyAttributeRestrictionsNestedImpl(item);
    }

    public A withBuildAttributeRestrictions(Build buildAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (buildAttributeRestrictions!=null){ this.attributeRestrictions= new BuildBuilder(buildAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.BuildAttributeRestrictionsNested withNewBuildAttributeRestrictions(){
            return new BuildAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.BuildAttributeRestrictionsNested withNewBuildAttributeRestrictionsLike(Build item){
            return new BuildAttributeRestrictionsNestedImpl(item);
    }

    public A withScaleAttributeRestrictions(Scale scaleAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (scaleAttributeRestrictions!=null){ this.attributeRestrictions= new ScaleBuilder(scaleAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ScaleAttributeRestrictionsNested withNewScaleAttributeRestrictions(){
            return new ScaleAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ScaleAttributeRestrictionsNested withNewScaleAttributeRestrictionsLike(Scale item){
            return new ScaleAttributeRestrictionsNestedImpl(item);
    }

    public A withPodAttributeRestrictions(Pod podAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (podAttributeRestrictions!=null){ this.attributeRestrictions= new PodBuilder(podAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PodAttributeRestrictionsNested withNewPodAttributeRestrictions(){
            return new PodAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PodAttributeRestrictionsNested withNewPodAttributeRestrictionsLike(Pod item){
            return new PodAttributeRestrictionsNestedImpl(item);
    }

    public A withHorizontalPodAutoscalerAttributeRestrictions(HorizontalPodAutoscaler horizontalPodAutoscalerAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (horizontalPodAutoscalerAttributeRestrictions!=null){ this.attributeRestrictions= new HorizontalPodAutoscalerBuilder(horizontalPodAutoscalerAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.HorizontalPodAutoscalerAttributeRestrictionsNested withNewHorizontalPodAutoscalerAttributeRestrictions(){
            return new HorizontalPodAutoscalerAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.HorizontalPodAutoscalerAttributeRestrictionsNested withNewHorizontalPodAutoscalerAttributeRestrictionsLike(HorizontalPodAutoscaler item){
            return new HorizontalPodAutoscalerAttributeRestrictionsNestedImpl(item);
    }

    public A withThirdPartyResourceAttributeRestrictions(ThirdPartyResource thirdPartyResourceAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (thirdPartyResourceAttributeRestrictions!=null){ this.attributeRestrictions= new ThirdPartyResourceBuilder(thirdPartyResourceAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ThirdPartyResourceAttributeRestrictionsNested withNewThirdPartyResourceAttributeRestrictions(){
            return new ThirdPartyResourceAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ThirdPartyResourceAttributeRestrictionsNested withNewThirdPartyResourceAttributeRestrictionsLike(ThirdPartyResource item){
            return new ThirdPartyResourceAttributeRestrictionsNestedImpl(item);
    }

    public A withImageStreamTagAttributeRestrictions(ImageStreamTag imageStreamTagAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (imageStreamTagAttributeRestrictions!=null){ this.attributeRestrictions= new ImageStreamTagBuilder(imageStreamTagAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ImageStreamTagAttributeRestrictionsNested withNewImageStreamTagAttributeRestrictions(){
            return new ImageStreamTagAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ImageStreamTagAttributeRestrictionsNested withNewImageStreamTagAttributeRestrictionsLike(ImageStreamTag item){
            return new ImageStreamTagAttributeRestrictionsNestedImpl(item);
    }

    public A withComponentStatusAttributeRestrictions(ComponentStatus componentStatusAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (componentStatusAttributeRestrictions!=null){ this.attributeRestrictions= new ComponentStatusBuilder(componentStatusAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ComponentStatusAttributeRestrictionsNested withNewComponentStatusAttributeRestrictions(){
            return new ComponentStatusAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ComponentStatusAttributeRestrictionsNested withNewComponentStatusAttributeRestrictionsLike(ComponentStatus item){
            return new ComponentStatusAttributeRestrictionsNestedImpl(item);
    }

    public A withSecretAttributeRestrictions(Secret secretAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (secretAttributeRestrictions!=null){ this.attributeRestrictions= new SecretBuilder(secretAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.SecretAttributeRestrictionsNested withNewSecretAttributeRestrictions(){
            return new SecretAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.SecretAttributeRestrictionsNested withNewSecretAttributeRestrictionsLike(Secret item){
            return new SecretAttributeRestrictionsNestedImpl(item);
    }

    public A withReplicationControllerAttributeRestrictions(ReplicationController replicationControllerAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (replicationControllerAttributeRestrictions!=null){ this.attributeRestrictions= new ReplicationControllerBuilder(replicationControllerAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ReplicationControllerAttributeRestrictionsNested withNewReplicationControllerAttributeRestrictions(){
            return new ReplicationControllerAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ReplicationControllerAttributeRestrictionsNested withNewReplicationControllerAttributeRestrictionsLike(ReplicationController item){
            return new ReplicationControllerAttributeRestrictionsNestedImpl(item);
    }

    public A withLimitRangeAttributeRestrictions(LimitRange limitRangeAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (limitRangeAttributeRestrictions!=null){ this.attributeRestrictions= new LimitRangeBuilder(limitRangeAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.LimitRangeAttributeRestrictionsNested withNewLimitRangeAttributeRestrictions(){
            return new LimitRangeAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.LimitRangeAttributeRestrictionsNested withNewLimitRangeAttributeRestrictionsLike(LimitRange item){
            return new LimitRangeAttributeRestrictionsNestedImpl(item);
    }

    public A withEndpointsAttributeRestrictions(Endpoints endpointsAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (endpointsAttributeRestrictions!=null){ this.attributeRestrictions= new EndpointsBuilder(endpointsAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.EndpointsAttributeRestrictionsNested withNewEndpointsAttributeRestrictions(){
            return new EndpointsAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.EndpointsAttributeRestrictionsNested withNewEndpointsAttributeRestrictionsLike(Endpoints item){
            return new EndpointsAttributeRestrictionsNestedImpl(item);
    }

    public A withSecurityContextConstraintsAttributeRestrictions(SecurityContextConstraints securityContextConstraintsAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (securityContextConstraintsAttributeRestrictions!=null){ this.attributeRestrictions= new SecurityContextConstraintsBuilder(securityContextConstraintsAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.SecurityContextConstraintsAttributeRestrictionsNested withNewSecurityContextConstraintsAttributeRestrictions(){
            return new SecurityContextConstraintsAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.SecurityContextConstraintsAttributeRestrictionsNested withNewSecurityContextConstraintsAttributeRestrictionsLike(SecurityContextConstraints item){
            return new SecurityContextConstraintsAttributeRestrictionsNestedImpl(item);
    }

    public A withGroupAttributeRestrictions(Group groupAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (groupAttributeRestrictions!=null){ this.attributeRestrictions= new GroupBuilder(groupAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.GroupAttributeRestrictionsNested withNewGroupAttributeRestrictions(){
            return new GroupAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.GroupAttributeRestrictionsNested withNewGroupAttributeRestrictionsLike(Group item){
            return new GroupAttributeRestrictionsNestedImpl(item);
    }

    public A withEventAttributeRestrictions(Event eventAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (eventAttributeRestrictions!=null){ this.attributeRestrictions= new EventBuilder(eventAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.EventAttributeRestrictionsNested withNewEventAttributeRestrictions(){
            return new EventAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.EventAttributeRestrictionsNested withNewEventAttributeRestrictionsLike(Event item){
            return new EventAttributeRestrictionsNestedImpl(item);
    }

    public A withNodeAttributeRestrictions(Node nodeAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (nodeAttributeRestrictions!=null){ this.attributeRestrictions= new NodeBuilder(nodeAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.NodeAttributeRestrictionsNested withNewNodeAttributeRestrictions(){
            return new NodeAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.NodeAttributeRestrictionsNested withNewNodeAttributeRestrictionsLike(Node item){
            return new NodeAttributeRestrictionsNestedImpl(item);
    }

    public A withReplicaSetAttributeRestrictions(ReplicaSet replicaSetAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (replicaSetAttributeRestrictions!=null){ this.attributeRestrictions= new ReplicaSetBuilder(replicaSetAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ReplicaSetAttributeRestrictionsNested withNewReplicaSetAttributeRestrictions(){
            return new ReplicaSetAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ReplicaSetAttributeRestrictionsNested withNewReplicaSetAttributeRestrictionsLike(ReplicaSet item){
            return new ReplicaSetAttributeRestrictionsNestedImpl(item);
    }

    public A withClusterRoleBindingAttributeRestrictions(ClusterRoleBinding clusterRoleBindingAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (clusterRoleBindingAttributeRestrictions!=null){ this.attributeRestrictions= new ClusterRoleBindingBuilder(clusterRoleBindingAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ClusterRoleBindingAttributeRestrictionsNested withNewClusterRoleBindingAttributeRestrictions(){
            return new ClusterRoleBindingAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ClusterRoleBindingAttributeRestrictionsNested withNewClusterRoleBindingAttributeRestrictionsLike(ClusterRoleBinding item){
            return new ClusterRoleBindingAttributeRestrictionsNestedImpl(item);
    }

    public A withJenkinsAttributeRestrictions(Jenkins jenkinsAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (jenkinsAttributeRestrictions!=null){ this.attributeRestrictions= new JenkinsBuilder(jenkinsAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.JenkinsAttributeRestrictionsNested withNewJenkinsAttributeRestrictions(){
            return new JenkinsAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.JenkinsAttributeRestrictionsNested withNewJenkinsAttributeRestrictionsLike(Jenkins item){
            return new JenkinsAttributeRestrictionsNestedImpl(item);
    }

    public A withDaemonSetAttributeRestrictions(DaemonSet daemonSetAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (daemonSetAttributeRestrictions!=null){ this.attributeRestrictions= new DaemonSetBuilder(daemonSetAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.DaemonSetAttributeRestrictionsNested withNewDaemonSetAttributeRestrictions(){
            return new DaemonSetAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.DaemonSetAttributeRestrictionsNested withNewDaemonSetAttributeRestrictionsLike(DaemonSet item){
            return new DaemonSetAttributeRestrictionsNestedImpl(item);
    }

    public A withPodDisruptionBudgetAttributeRestrictions(PodDisruptionBudget podDisruptionBudgetAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (podDisruptionBudgetAttributeRestrictions!=null){ this.attributeRestrictions= new PodDisruptionBudgetBuilder(podDisruptionBudgetAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PodDisruptionBudgetAttributeRestrictionsNested withNewPodDisruptionBudgetAttributeRestrictions(){
            return new PodDisruptionBudgetAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PodDisruptionBudgetAttributeRestrictionsNested withNewPodDisruptionBudgetAttributeRestrictionsLike(PodDisruptionBudget item){
            return new PodDisruptionBudgetAttributeRestrictionsNestedImpl(item);
    }

    public A withImageStreamAttributeRestrictions(ImageStream imageStreamAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (imageStreamAttributeRestrictions!=null){ this.attributeRestrictions= new ImageStreamBuilder(imageStreamAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ImageStreamAttributeRestrictionsNested withNewImageStreamAttributeRestrictions(){
            return new ImageStreamAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ImageStreamAttributeRestrictionsNested withNewImageStreamAttributeRestrictionsLike(ImageStream item){
            return new ImageStreamAttributeRestrictionsNestedImpl(item);
    }

    public A withRoleBindingRestrictionAttributeRestrictions(RoleBindingRestriction roleBindingRestrictionAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (roleBindingRestrictionAttributeRestrictions!=null){ this.attributeRestrictions= new RoleBindingRestrictionBuilder(roleBindingRestrictionAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.RoleBindingRestrictionAttributeRestrictionsNested withNewRoleBindingRestrictionAttributeRestrictions(){
            return new RoleBindingRestrictionAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.RoleBindingRestrictionAttributeRestrictionsNested withNewRoleBindingRestrictionAttributeRestrictionsLike(RoleBindingRestriction item){
            return new RoleBindingRestrictionAttributeRestrictionsNestedImpl(item);
    }

    public A withBindingAttributeRestrictions(Binding bindingAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (bindingAttributeRestrictions!=null){ this.attributeRestrictions= new BindingBuilder(bindingAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.BindingAttributeRestrictionsNested withNewBindingAttributeRestrictions(){
            return new BindingAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.BindingAttributeRestrictionsNested withNewBindingAttributeRestrictionsLike(Binding item){
            return new BindingAttributeRestrictionsNestedImpl(item);
    }

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

    public PolicyRuleFluent.AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNested withNewAuthorizationLocalSubjectAccessReviewAttributeRestrictions(){
            return new AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNested withNewLocalSubjectAccessReviewAttributeRestrictionsLike(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
            return new AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNestedImpl(item);
    }

    public A withStatefulSetAttributeRestrictions(StatefulSet statefulSetAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (statefulSetAttributeRestrictions!=null){ this.attributeRestrictions= new StatefulSetBuilder(statefulSetAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.StatefulSetAttributeRestrictionsNested withNewStatefulSetAttributeRestrictions(){
            return new StatefulSetAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.StatefulSetAttributeRestrictionsNested withNewStatefulSetAttributeRestrictionsLike(StatefulSet item){
            return new StatefulSetAttributeRestrictionsNestedImpl(item);
    }

    public A withPipelineTemplateTaskInstanceAttributeRestrictions(PipelineTemplateTaskInstance pipelineTemplateTaskInstanceAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (pipelineTemplateTaskInstanceAttributeRestrictions!=null){ this.attributeRestrictions= new PipelineTemplateTaskInstanceBuilder(pipelineTemplateTaskInstanceAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PipelineTemplateTaskInstanceAttributeRestrictionsNested withNewPipelineTemplateTaskInstanceAttributeRestrictions(){
            return new PipelineTemplateTaskInstanceAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PipelineTemplateTaskInstanceAttributeRestrictionsNested withNewPipelineTemplateTaskInstanceAttributeRestrictionsLike(PipelineTemplateTaskInstance item){
            return new PipelineTemplateTaskInstanceAttributeRestrictionsNestedImpl(item);
    }

    public A withOAuthClientAttributeRestrictions(OAuthClient oAuthClientAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (oAuthClientAttributeRestrictions!=null){ this.attributeRestrictions= new OAuthClientBuilder(oAuthClientAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.OAuthClientAttributeRestrictionsNested withNewOAuthClientAttributeRestrictions(){
            return new OAuthClientAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.OAuthClientAttributeRestrictionsNested withNewOAuthClientAttributeRestrictionsLike(OAuthClient item){
            return new OAuthClientAttributeRestrictionsNestedImpl(item);
    }

    public A withTemplateAttributeRestrictions(Template templateAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (templateAttributeRestrictions!=null){ this.attributeRestrictions= new TemplateBuilder(templateAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.TemplateAttributeRestrictionsNested withNewTemplateAttributeRestrictions(){
            return new TemplateAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.TemplateAttributeRestrictionsNested withNewTemplateAttributeRestrictionsLike(Template item){
            return new TemplateAttributeRestrictionsNestedImpl(item);
    }

    public A withBuildConfigAttributeRestrictions(BuildConfig buildConfigAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (buildConfigAttributeRestrictions!=null){ this.attributeRestrictions= new BuildConfigBuilder(buildConfigAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.BuildConfigAttributeRestrictionsNested withNewBuildConfigAttributeRestrictions(){
            return new BuildConfigAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.BuildConfigAttributeRestrictionsNested withNewBuildConfigAttributeRestrictionsLike(BuildConfig item){
            return new BuildConfigAttributeRestrictionsNestedImpl(item);
    }

    public A withPodSecurityPolicyAttributeRestrictions(PodSecurityPolicy podSecurityPolicyAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (podSecurityPolicyAttributeRestrictions!=null){ this.attributeRestrictions= new PodSecurityPolicyBuilder(podSecurityPolicyAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PodSecurityPolicyAttributeRestrictionsNested withNewPodSecurityPolicyAttributeRestrictions(){
            return new PodSecurityPolicyAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PodSecurityPolicyAttributeRestrictionsNested withNewPodSecurityPolicyAttributeRestrictionsLike(PodSecurityPolicy item){
            return new PodSecurityPolicyAttributeRestrictionsNestedImpl(item);
    }

    public A withPipelineAttributeRestrictions(Pipeline pipelineAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (pipelineAttributeRestrictions!=null){ this.attributeRestrictions= new PipelineBuilder(pipelineAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PipelineAttributeRestrictionsNested withNewPipelineAttributeRestrictions(){
            return new PipelineAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PipelineAttributeRestrictionsNested withNewPipelineAttributeRestrictionsLike(Pipeline item){
            return new PipelineAttributeRestrictionsNestedImpl(item);
    }

    public A withRoleAttributeRestrictions(Role roleAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (roleAttributeRestrictions!=null){ this.attributeRestrictions= new RoleBuilder(roleAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.RoleAttributeRestrictionsNested withNewRoleAttributeRestrictions(){
            return new RoleAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.RoleAttributeRestrictionsNested withNewRoleAttributeRestrictionsLike(Role item){
            return new RoleAttributeRestrictionsNestedImpl(item);
    }

    public A withCronJobAttributeRestrictions(CronJob cronJobAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (cronJobAttributeRestrictions!=null){ this.attributeRestrictions= new CronJobBuilder(cronJobAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.CronJobAttributeRestrictionsNested withNewCronJobAttributeRestrictions(){
            return new CronJobAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.CronJobAttributeRestrictionsNested withNewCronJobAttributeRestrictionsLike(CronJob item){
            return new CronJobAttributeRestrictionsNestedImpl(item);
    }

    public A withUserAttributeRestrictions(User userAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (userAttributeRestrictions!=null){ this.attributeRestrictions= new UserBuilder(userAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.UserAttributeRestrictionsNested withNewUserAttributeRestrictions(){
            return new UserAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.UserAttributeRestrictionsNested withNewUserAttributeRestrictionsLike(User item){
            return new UserAttributeRestrictionsNestedImpl(item);
    }

    public A withSubjectAccessReviewAttributeRestrictions(io.alauda.kubernetes.api.model.authorization.SubjectAccessReview subjectAccessReviewAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (subjectAccessReviewAttributeRestrictions!=null){ this.attributeRestrictions= new io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder(subjectAccessReviewAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.AuthorizationSubjectAccessReviewAttributeRestrictionsNested withNewAuthorizationSubjectAccessReviewAttributeRestrictions(){
            return new AuthorizationSubjectAccessReviewAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.AuthorizationSubjectAccessReviewAttributeRestrictionsNested withNewSubjectAccessReviewAttributeRestrictionsLike(io.alauda.kubernetes.api.model.authorization.SubjectAccessReview item){
            return new AuthorizationSubjectAccessReviewAttributeRestrictionsNestedImpl(item);
    }

    public A withStorageClassAttributeRestrictions(StorageClass storageClassAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (storageClassAttributeRestrictions!=null){ this.attributeRestrictions= new StorageClassBuilder(storageClassAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.StorageClassAttributeRestrictionsNested withNewStorageClassAttributeRestrictions(){
            return new StorageClassAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.StorageClassAttributeRestrictionsNested withNewStorageClassAttributeRestrictionsLike(StorageClass item){
            return new StorageClassAttributeRestrictionsNestedImpl(item);
    }

    public A withPipelineConfigTemplateAttributeRestrictions(PipelineConfigTemplate pipelineConfigTemplateAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (pipelineConfigTemplateAttributeRestrictions!=null){ this.attributeRestrictions= new PipelineConfigTemplateBuilder(pipelineConfigTemplateAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PipelineConfigTemplateAttributeRestrictionsNested withNewPipelineConfigTemplateAttributeRestrictions(){
            return new PipelineConfigTemplateAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PipelineConfigTemplateAttributeRestrictionsNested withNewPipelineConfigTemplateAttributeRestrictionsLike(PipelineConfigTemplate item){
            return new PipelineConfigTemplateAttributeRestrictionsNestedImpl(item);
    }

    public A withPipelineConfigAttributeRestrictions(PipelineConfig pipelineConfigAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (pipelineConfigAttributeRestrictions!=null){ this.attributeRestrictions= new PipelineConfigBuilder(pipelineConfigAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PipelineConfigAttributeRestrictionsNested withNewPipelineConfigAttributeRestrictions(){
            return new PipelineConfigAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PipelineConfigAttributeRestrictionsNested withNewPipelineConfigAttributeRestrictionsLike(PipelineConfig item){
            return new PipelineConfigAttributeRestrictionsNestedImpl(item);
    }

    public A withDeploymentConfigAttributeRestrictions(DeploymentConfig deploymentConfigAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (deploymentConfigAttributeRestrictions!=null){ this.attributeRestrictions= new DeploymentConfigBuilder(deploymentConfigAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.DeploymentConfigAttributeRestrictionsNested withNewDeploymentConfigAttributeRestrictions(){
            return new DeploymentConfigAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.DeploymentConfigAttributeRestrictionsNested withNewDeploymentConfigAttributeRestrictionsLike(DeploymentConfig item){
            return new DeploymentConfigAttributeRestrictionsNestedImpl(item);
    }

    public A withOAuthAccessTokenAttributeRestrictions(OAuthAccessToken oAuthAccessTokenAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (oAuthAccessTokenAttributeRestrictions!=null){ this.attributeRestrictions= new OAuthAccessTokenBuilder(oAuthAccessTokenAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.OAuthAccessTokenAttributeRestrictionsNested withNewOAuthAccessTokenAttributeRestrictions(){
            return new OAuthAccessTokenAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.OAuthAccessTokenAttributeRestrictionsNested withNewOAuthAccessTokenAttributeRestrictionsLike(OAuthAccessToken item){
            return new OAuthAccessTokenAttributeRestrictionsNestedImpl(item);
    }

    public A withPersistentVolumeClaimAttributeRestrictions(PersistentVolumeClaim persistentVolumeClaimAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (persistentVolumeClaimAttributeRestrictions!=null){ this.attributeRestrictions= new PersistentVolumeClaimBuilder(persistentVolumeClaimAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PersistentVolumeClaimAttributeRestrictionsNested withNewPersistentVolumeClaimAttributeRestrictions(){
            return new PersistentVolumeClaimAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PersistentVolumeClaimAttributeRestrictionsNested withNewPersistentVolumeClaimAttributeRestrictionsLike(PersistentVolumeClaim item){
            return new PersistentVolumeClaimAttributeRestrictionsNestedImpl(item);
    }

    public A withNetworkPolicyAttributeRestrictions(NetworkPolicy networkPolicyAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (networkPolicyAttributeRestrictions!=null){ this.attributeRestrictions= new NetworkPolicyBuilder(networkPolicyAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.NetworkPolicyAttributeRestrictionsNested withNewNetworkPolicyAttributeRestrictions(){
            return new NetworkPolicyAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.NetworkPolicyAttributeRestrictionsNested withNewNetworkPolicyAttributeRestrictionsLike(NetworkPolicy item){
            return new NetworkPolicyAttributeRestrictionsNestedImpl(item);
    }

    public A withImageAttributeRestrictions(Image imageAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (imageAttributeRestrictions!=null){ this.attributeRestrictions= new ImageBuilder(imageAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ImageAttributeRestrictionsNested withNewImageAttributeRestrictions(){
            return new ImageAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ImageAttributeRestrictionsNested withNewImageAttributeRestrictionsLike(Image item){
            return new ImageAttributeRestrictionsNestedImpl(item);
    }

    public A withServiceAttributeRestrictions(Service serviceAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (serviceAttributeRestrictions!=null){ this.attributeRestrictions= new ServiceBuilder(serviceAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ServiceAttributeRestrictionsNested withNewServiceAttributeRestrictions(){
            return new ServiceAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ServiceAttributeRestrictionsNested withNewServiceAttributeRestrictionsLike(Service item){
            return new ServiceAttributeRestrictionsNestedImpl(item);
    }

    public A withJobAttributeRestrictions(Job jobAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (jobAttributeRestrictions!=null){ this.attributeRestrictions= new JobBuilder(jobAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.JobAttributeRestrictionsNested withNewJobAttributeRestrictions(){
            return new JobAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.JobAttributeRestrictionsNested withNewJobAttributeRestrictionsLike(Job item){
            return new JobAttributeRestrictionsNestedImpl(item);
    }

    public A withDeploymentAttributeRestrictions(Deployment deploymentAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (deploymentAttributeRestrictions!=null){ this.attributeRestrictions= new DeploymentBuilder(deploymentAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.DeploymentAttributeRestrictionsNested withNewDeploymentAttributeRestrictions(){
            return new DeploymentAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.DeploymentAttributeRestrictionsNested withNewDeploymentAttributeRestrictionsLike(Deployment item){
            return new DeploymentAttributeRestrictionsNestedImpl(item);
    }

    public A withClusterPolicyBindingAttributeRestrictions(ClusterPolicyBinding clusterPolicyBindingAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (clusterPolicyBindingAttributeRestrictions!=null){ this.attributeRestrictions= new ClusterPolicyBindingBuilder(clusterPolicyBindingAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ClusterPolicyBindingAttributeRestrictionsNested withNewClusterPolicyBindingAttributeRestrictions(){
            return new ClusterPolicyBindingAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ClusterPolicyBindingAttributeRestrictionsNested withNewClusterPolicyBindingAttributeRestrictionsLike(ClusterPolicyBinding item){
            return new ClusterPolicyBindingAttributeRestrictionsNestedImpl(item);
    }

    public A withProjectAttributeRestrictions(Project projectAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (projectAttributeRestrictions!=null){ this.attributeRestrictions= new ProjectBuilder(projectAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.ProjectAttributeRestrictionsNested withNewProjectAttributeRestrictions(){
            return new ProjectAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.ProjectAttributeRestrictionsNested withNewProjectAttributeRestrictionsLike(Project item){
            return new ProjectAttributeRestrictionsNestedImpl(item);
    }

    public A withBuildRequestAttributeRestrictions(BuildRequest buildRequestAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (buildRequestAttributeRestrictions!=null){ this.attributeRestrictions= new BuildRequestBuilder(buildRequestAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.BuildRequestAttributeRestrictionsNested withNewBuildRequestAttributeRestrictions(){
            return new BuildRequestAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.BuildRequestAttributeRestrictionsNested withNewBuildRequestAttributeRestrictionsLike(BuildRequest item){
            return new BuildRequestAttributeRestrictionsNestedImpl(item);
    }

    public A withRoleBindingAttributeRestrictions(RoleBinding roleBindingAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (roleBindingAttributeRestrictions!=null){ this.attributeRestrictions= new RoleBindingBuilder(roleBindingAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.RoleBindingAttributeRestrictionsNested withNewRoleBindingAttributeRestrictions(){
            return new RoleBindingAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.RoleBindingAttributeRestrictionsNested withNewRoleBindingAttributeRestrictionsLike(RoleBinding item){
            return new RoleBindingAttributeRestrictionsNestedImpl(item);
    }

    public A withPersistentVolumeAttributeRestrictions(PersistentVolume persistentVolumeAttributeRestrictions){
            _visitables.remove(this.attributeRestrictions);
            if (persistentVolumeAttributeRestrictions!=null){ this.attributeRestrictions= new PersistentVolumeBuilder(persistentVolumeAttributeRestrictions); _visitables.add(this.attributeRestrictions);} return (A) this;
    }

    public PolicyRuleFluent.PersistentVolumeAttributeRestrictionsNested withNewPersistentVolumeAttributeRestrictions(){
            return new PersistentVolumeAttributeRestrictionsNestedImpl();
    }

    public PolicyRuleFluent.PersistentVolumeAttributeRestrictionsNested withNewPersistentVolumeAttributeRestrictionsLike(PersistentVolume item){
            return new PersistentVolumeAttributeRestrictionsNestedImpl(item);
    }

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

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

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

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

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

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

    public List getNonResourceURLs(){
            return this.nonResourceURLs;
    }

    public String getNonResourceURL(int index){
            return this.nonResourceURLs.get(index);
    }

    public String getFirstNonResourceURL(){
            return this.nonResourceURLs.get(0);
    }

    public String getLastNonResourceURL(){
            return this.nonResourceURLs.get(nonResourceURLs.size() - 1);
    }

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

    public A withNonResourceURLs(List nonResourceURLs){
            this.nonResourceURLs.clear();
            if (nonResourceURLs != null) {for (String item : nonResourceURLs){this.addToNonResourceURLs(item);}} return (A) this;
    }

    public A withNonResourceURLs(String... nonResourceURLs){
            this.nonResourceURLs.clear(); if (nonResourceURLs != null) {for (String item :nonResourceURLs){ this.addToNonResourceURLs(item);}} return (A) this;
    }

    public Boolean hasNonResourceURLs(){
            return nonResourceURLs!= null && !nonResourceURLs.isEmpty();
    }

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

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

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

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

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

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

    public List getResourceNames(){
            return this.resourceNames;
    }

    public String getResourceName(int index){
            return this.resourceNames.get(index);
    }

    public String getFirstResourceName(){
            return this.resourceNames.get(0);
    }

    public String getLastResourceName(){
            return this.resourceNames.get(resourceNames.size() - 1);
    }

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

    public A withResourceNames(List resourceNames){
            this.resourceNames.clear();
            if (resourceNames != null) {for (String item : resourceNames){this.addToResourceNames(item);}} return (A) this;
    }

    public A withResourceNames(String... resourceNames){
            this.resourceNames.clear(); if (resourceNames != null) {for (String item :resourceNames){ this.addToResourceNames(item);}} return (A) this;
    }

    public Boolean hasResourceNames(){
            return resourceNames!= null && !resourceNames.isEmpty();
    }

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

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

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

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

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

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

    public List getResources(){
            return this.resources;
    }

    public String getResource(int index){
            return this.resources.get(index);
    }

    public String getFirstResource(){
            return this.resources.get(0);
    }

    public String getLastResource(){
            return this.resources.get(resources.size() - 1);
    }

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

    public A withResources(List resources){
            this.resources.clear();
            if (resources != null) {for (String item : resources){this.addToResources(item);}} return (A) this;
    }

    public A withResources(String... resources){
            this.resources.clear(); if (resources != null) {for (String item :resources){ this.addToResources(item);}} return (A) this;
    }

    public Boolean hasResources(){
            return resources!= null && !resources.isEmpty();
    }

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

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

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

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

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

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

    public List getVerbs(){
            return this.verbs;
    }

    public String getVerb(int index){
            return this.verbs.get(index);
    }

    public String getFirstVerb(){
            return this.verbs.get(0);
    }

    public String getLastVerb(){
            return this.verbs.get(verbs.size() - 1);
    }

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

    public A withVerbs(List verbs){
            this.verbs.clear();
            if (verbs != null) {for (String item : verbs){this.addToVerbs(item);}} return (A) this;
    }

    public A withVerbs(String... verbs){
            this.verbs.clear(); if (verbs != null) {for (String item :verbs){ this.addToVerbs(item);}} return (A) this;
    }

    public Boolean hasVerbs(){
            return verbs!= null && !verbs.isEmpty();
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            PolicyRuleFluentImpl that = (PolicyRuleFluentImpl) o;
            if (apiGroups != null ? !apiGroups.equals(that.apiGroups) :that.apiGroups != null) return false;
            if (attributeRestrictions != null ? !attributeRestrictions.equals(that.attributeRestrictions) :that.attributeRestrictions != null) return false;
            if (nonResourceURLs != null ? !nonResourceURLs.equals(that.nonResourceURLs) :that.nonResourceURLs != null) return false;
            if (resourceNames != null ? !resourceNames.equals(that.resourceNames) :that.resourceNames != null) return false;
            if (resources != null ? !resources.equals(that.resources) :that.resources != null) return false;
            if (verbs != null ? !verbs.equals(that.verbs) :that.verbs != null) return false;
            return true;
    }


    public class IngressAttributeRestrictionsNestedImpl extends IngressFluentImpl> implements PolicyRuleFluent.IngressAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressBuilder builder;
    
            IngressAttributeRestrictionsNestedImpl(Ingress item){
                    this.builder = new IngressBuilder(this, item);
            }
            IngressAttributeRestrictionsNestedImpl(){
                    this.builder = new IngressBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withIngressAttributeRestrictions(builder.build());
    }
    public N endIngressAttributeRestrictions(){
            return and();
    }

}
    public class RouteAttributeRestrictionsNestedImpl extends RouteFluentImpl> implements PolicyRuleFluent.RouteAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final RouteBuilder builder;
    
            RouteAttributeRestrictionsNestedImpl(Route item){
                    this.builder = new RouteBuilder(this, item);
            }
            RouteAttributeRestrictionsNestedImpl(){
                    this.builder = new RouteBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withRouteAttributeRestrictions(builder.build());
    }
    public N endRouteAttributeRestrictions(){
            return and();
    }

}
    public class PolicyBindingAttributeRestrictionsNestedImpl extends PolicyBindingFluentImpl> implements PolicyRuleFluent.PolicyBindingAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBindingBuilder builder;
    
            PolicyBindingAttributeRestrictionsNestedImpl(PolicyBinding item){
                    this.builder = new PolicyBindingBuilder(this, item);
            }
            PolicyBindingAttributeRestrictionsNestedImpl(){
                    this.builder = new PolicyBindingBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPolicyBindingAttributeRestrictions(builder.build());
    }
    public N endPolicyBindingAttributeRestrictions(){
            return and();
    }

}
    public class ResourceQuotaAttributeRestrictionsNestedImpl extends ResourceQuotaFluentImpl> implements PolicyRuleFluent.ResourceQuotaAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaBuilder builder;
    
            ResourceQuotaAttributeRestrictionsNestedImpl(ResourceQuota item){
                    this.builder = new ResourceQuotaBuilder(this, item);
            }
            ResourceQuotaAttributeRestrictionsNestedImpl(){
                    this.builder = new ResourceQuotaBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withResourceQuotaAttributeRestrictions(builder.build());
    }
    public N endResourceQuotaAttributeRestrictions(){
            return and();
    }

}
    public class ServiceAccountAttributeRestrictionsNestedImpl extends ServiceAccountFluentImpl> implements PolicyRuleFluent.ServiceAccountAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountBuilder builder;
    
            ServiceAccountAttributeRestrictionsNestedImpl(ServiceAccount item){
                    this.builder = new ServiceAccountBuilder(this, item);
            }
            ServiceAccountAttributeRestrictionsNestedImpl(){
                    this.builder = new ServiceAccountBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withServiceAccountAttributeRestrictions(builder.build());
    }
    public N endServiceAccountAttributeRestrictions(){
            return and();
    }

}
    public class ConfigMapAttributeRestrictionsNestedImpl extends ConfigMapFluentImpl> implements PolicyRuleFluent.ConfigMapAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapBuilder builder;
    
            ConfigMapAttributeRestrictionsNestedImpl(ConfigMap item){
                    this.builder = new ConfigMapBuilder(this, item);
            }
            ConfigMapAttributeRestrictionsNestedImpl(){
                    this.builder = new ConfigMapBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withConfigMapAttributeRestrictions(builder.build());
    }
    public N endConfigMapAttributeRestrictions(){
            return and();
    }

}
    public class OAuthClientAuthorizationAttributeRestrictionsNestedImpl extends OAuthClientAuthorizationFluentImpl> implements PolicyRuleFluent.OAuthClientAuthorizationAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientAuthorizationBuilder builder;
    
            OAuthClientAuthorizationAttributeRestrictionsNestedImpl(OAuthClientAuthorization item){
                    this.builder = new OAuthClientAuthorizationBuilder(this, item);
            }
            OAuthClientAuthorizationAttributeRestrictionsNestedImpl(){
                    this.builder = new OAuthClientAuthorizationBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withOAuthClientAuthorizationAttributeRestrictions(builder.build());
    }
    public N endOAuthClientAuthorizationAttributeRestrictions(){
            return and();
    }

}
    public class PolicyAttributeRestrictionsNestedImpl extends PolicyFluentImpl> implements PolicyRuleFluent.PolicyAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBuilder builder;
    
            PolicyAttributeRestrictionsNestedImpl(Policy item){
                    this.builder = new PolicyBuilder(this, item);
            }
            PolicyAttributeRestrictionsNestedImpl(){
                    this.builder = new PolicyBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPolicyAttributeRestrictions(builder.build());
    }
    public N endPolicyAttributeRestrictions(){
            return and();
    }

}
    public class OAuthAuthorizeTokenAttributeRestrictionsNestedImpl extends OAuthAuthorizeTokenFluentImpl> implements PolicyRuleFluent.OAuthAuthorizeTokenAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAuthorizeTokenBuilder builder;
    
            OAuthAuthorizeTokenAttributeRestrictionsNestedImpl(OAuthAuthorizeToken item){
                    this.builder = new OAuthAuthorizeTokenBuilder(this, item);
            }
            OAuthAuthorizeTokenAttributeRestrictionsNestedImpl(){
                    this.builder = new OAuthAuthorizeTokenBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withOAuthAuthorizeTokenAttributeRestrictions(builder.build());
    }
    public N endOAuthAuthorizeTokenAttributeRestrictions(){
            return and();
    }

}
    public class JenkinsBindingAttributeRestrictionsNestedImpl extends JenkinsBindingFluentImpl> implements PolicyRuleFluent.JenkinsBindingAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingBuilder builder;
    
            JenkinsBindingAttributeRestrictionsNestedImpl(JenkinsBinding item){
                    this.builder = new JenkinsBindingBuilder(this, item);
            }
            JenkinsBindingAttributeRestrictionsNestedImpl(){
                    this.builder = new JenkinsBindingBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withJenkinsBindingAttributeRestrictions(builder.build());
    }
    public N endJenkinsBindingAttributeRestrictions(){
            return and();
    }

}
    public class IdentityAttributeRestrictionsNestedImpl extends IdentityFluentImpl> implements PolicyRuleFluent.IdentityAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final IdentityBuilder builder;
    
            IdentityAttributeRestrictionsNestedImpl(Identity item){
                    this.builder = new IdentityBuilder(this, item);
            }
            IdentityAttributeRestrictionsNestedImpl(){
                    this.builder = new IdentityBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withIdentityAttributeRestrictions(builder.build());
    }
    public N endIdentityAttributeRestrictions(){
            return and();
    }

}
    public class PodTemplateAttributeRestrictionsNestedImpl extends PodTemplateFluentImpl> implements PolicyRuleFluent.PodTemplateAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateBuilder builder;
    
            PodTemplateAttributeRestrictionsNestedImpl(PodTemplate item){
                    this.builder = new PodTemplateBuilder(this, item);
            }
            PodTemplateAttributeRestrictionsNestedImpl(){
                    this.builder = new PodTemplateBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPodTemplateAttributeRestrictions(builder.build());
    }
    public N endPodTemplateAttributeRestrictions(){
            return and();
    }

}
    public class TokenReviewAttributeRestrictionsNestedImpl extends TokenReviewFluentImpl> implements PolicyRuleFluent.TokenReviewAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewBuilder builder;
    
            TokenReviewAttributeRestrictionsNestedImpl(TokenReview item){
                    this.builder = new TokenReviewBuilder(this, item);
            }
            TokenReviewAttributeRestrictionsNestedImpl(){
                    this.builder = new TokenReviewBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withTokenReviewAttributeRestrictions(builder.build());
    }
    public N endTokenReviewAttributeRestrictions(){
            return and();
    }

}
    public class CustomResourceDefinitionAttributeRestrictionsNestedImpl extends CustomResourceDefinitionFluentImpl> implements PolicyRuleFluent.CustomResourceDefinitionAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionBuilder builder;
    
            CustomResourceDefinitionAttributeRestrictionsNestedImpl(CustomResourceDefinition item){
                    this.builder = new CustomResourceDefinitionBuilder(this, item);
            }
            CustomResourceDefinitionAttributeRestrictionsNestedImpl(){
                    this.builder = new CustomResourceDefinitionBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withCustomResourceDefinitionAttributeRestrictions(builder.build());
    }
    public N endCustomResourceDefinitionAttributeRestrictions(){
            return and();
    }

}
    public class ImageSignatureAttributeRestrictionsNestedImpl extends ImageSignatureFluentImpl> implements PolicyRuleFluent.ImageSignatureAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageSignatureBuilder builder;
    
            ImageSignatureAttributeRestrictionsNestedImpl(ImageSignature item){
                    this.builder = new ImageSignatureBuilder(this, item);
            }
            ImageSignatureAttributeRestrictionsNestedImpl(){
                    this.builder = new ImageSignatureBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withImageSignatureAttributeRestrictions(builder.build());
    }
    public N endImageSignatureAttributeRestrictions(){
            return and();
    }

}
    public class ClusterRoleAttributeRestrictionsNestedImpl extends ClusterRoleFluentImpl> implements PolicyRuleFluent.ClusterRoleAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterRoleBuilder builder;
    
            ClusterRoleAttributeRestrictionsNestedImpl(ClusterRole item){
                    this.builder = new ClusterRoleBuilder(this, item);
            }
            ClusterRoleAttributeRestrictionsNestedImpl(){
                    this.builder = new ClusterRoleBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withClusterRoleAttributeRestrictions(builder.build());
    }
    public N endClusterRoleAttributeRestrictions(){
            return and();
    }

}
    public class NamespaceAttributeRestrictionsNestedImpl extends NamespaceFluentImpl> implements PolicyRuleFluent.NamespaceAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceBuilder builder;
    
            NamespaceAttributeRestrictionsNestedImpl(Namespace item){
                    this.builder = new NamespaceBuilder(this, item);
            }
            NamespaceAttributeRestrictionsNestedImpl(){
                    this.builder = new NamespaceBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withNamespaceAttributeRestrictions(builder.build());
    }
    public N endNamespaceAttributeRestrictions(){
            return and();
    }

}
    public class ClusterPolicyAttributeRestrictionsNestedImpl extends ClusterPolicyFluentImpl> implements PolicyRuleFluent.ClusterPolicyAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBuilder builder;
    
            ClusterPolicyAttributeRestrictionsNestedImpl(ClusterPolicy item){
                    this.builder = new ClusterPolicyBuilder(this, item);
            }
            ClusterPolicyAttributeRestrictionsNestedImpl(){
                    this.builder = new ClusterPolicyBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withClusterPolicyAttributeRestrictions(builder.build());
    }
    public N endClusterPolicyAttributeRestrictions(){
            return and();
    }

}
    public class BuildAttributeRestrictionsNestedImpl extends BuildFluentImpl> implements PolicyRuleFluent.BuildAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildBuilder builder;
    
            BuildAttributeRestrictionsNestedImpl(Build item){
                    this.builder = new BuildBuilder(this, item);
            }
            BuildAttributeRestrictionsNestedImpl(){
                    this.builder = new BuildBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withBuildAttributeRestrictions(builder.build());
    }
    public N endBuildAttributeRestrictions(){
            return and();
    }

}
    public class ScaleAttributeRestrictionsNestedImpl extends ScaleFluentImpl> implements PolicyRuleFluent.ScaleAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleBuilder builder;
    
            ScaleAttributeRestrictionsNestedImpl(Scale item){
                    this.builder = new ScaleBuilder(this, item);
            }
            ScaleAttributeRestrictionsNestedImpl(){
                    this.builder = new ScaleBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withScaleAttributeRestrictions(builder.build());
    }
    public N endScaleAttributeRestrictions(){
            return and();
    }

}
    public class PodAttributeRestrictionsNestedImpl extends PodFluentImpl> implements PolicyRuleFluent.PodAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodBuilder builder;
    
            PodAttributeRestrictionsNestedImpl(Pod item){
                    this.builder = new PodBuilder(this, item);
            }
            PodAttributeRestrictionsNestedImpl(){
                    this.builder = new PodBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPodAttributeRestrictions(builder.build());
    }
    public N endPodAttributeRestrictions(){
            return and();
    }

}
    public class HorizontalPodAutoscalerAttributeRestrictionsNestedImpl extends HorizontalPodAutoscalerFluentImpl> implements PolicyRuleFluent.HorizontalPodAutoscalerAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerBuilder builder;
    
            HorizontalPodAutoscalerAttributeRestrictionsNestedImpl(HorizontalPodAutoscaler item){
                    this.builder = new HorizontalPodAutoscalerBuilder(this, item);
            }
            HorizontalPodAutoscalerAttributeRestrictionsNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withHorizontalPodAutoscalerAttributeRestrictions(builder.build());
    }
    public N endHorizontalPodAutoscalerAttributeRestrictions(){
            return and();
    }

}
    public class ThirdPartyResourceAttributeRestrictionsNestedImpl extends ThirdPartyResourceFluentImpl> implements PolicyRuleFluent.ThirdPartyResourceAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceBuilder builder;
    
            ThirdPartyResourceAttributeRestrictionsNestedImpl(ThirdPartyResource item){
                    this.builder = new ThirdPartyResourceBuilder(this, item);
            }
            ThirdPartyResourceAttributeRestrictionsNestedImpl(){
                    this.builder = new ThirdPartyResourceBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withThirdPartyResourceAttributeRestrictions(builder.build());
    }
    public N endThirdPartyResourceAttributeRestrictions(){
            return and();
    }

}
    public class ImageStreamTagAttributeRestrictionsNestedImpl extends ImageStreamTagFluentImpl> implements PolicyRuleFluent.ImageStreamTagAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageStreamTagBuilder builder;
    
            ImageStreamTagAttributeRestrictionsNestedImpl(ImageStreamTag item){
                    this.builder = new ImageStreamTagBuilder(this, item);
            }
            ImageStreamTagAttributeRestrictionsNestedImpl(){
                    this.builder = new ImageStreamTagBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withImageStreamTagAttributeRestrictions(builder.build());
    }
    public N endImageStreamTagAttributeRestrictions(){
            return and();
    }

}
    public class ComponentStatusAttributeRestrictionsNestedImpl extends ComponentStatusFluentImpl> implements PolicyRuleFluent.ComponentStatusAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentStatusBuilder builder;
    
            ComponentStatusAttributeRestrictionsNestedImpl(ComponentStatus item){
                    this.builder = new ComponentStatusBuilder(this, item);
            }
            ComponentStatusAttributeRestrictionsNestedImpl(){
                    this.builder = new ComponentStatusBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withComponentStatusAttributeRestrictions(builder.build());
    }
    public N endComponentStatusAttributeRestrictions(){
            return and();
    }

}
    public class SecretAttributeRestrictionsNestedImpl extends SecretFluentImpl> implements PolicyRuleFluent.SecretAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretBuilder builder;
    
            SecretAttributeRestrictionsNestedImpl(Secret item){
                    this.builder = new SecretBuilder(this, item);
            }
            SecretAttributeRestrictionsNestedImpl(){
                    this.builder = new SecretBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withSecretAttributeRestrictions(builder.build());
    }
    public N endSecretAttributeRestrictions(){
            return and();
    }

}
    public class ReplicationControllerAttributeRestrictionsNestedImpl extends ReplicationControllerFluentImpl> implements PolicyRuleFluent.ReplicationControllerAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerBuilder builder;
    
            ReplicationControllerAttributeRestrictionsNestedImpl(ReplicationController item){
                    this.builder = new ReplicationControllerBuilder(this, item);
            }
            ReplicationControllerAttributeRestrictionsNestedImpl(){
                    this.builder = new ReplicationControllerBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withReplicationControllerAttributeRestrictions(builder.build());
    }
    public N endReplicationControllerAttributeRestrictions(){
            return and();
    }

}
    public class LimitRangeAttributeRestrictionsNestedImpl extends LimitRangeFluentImpl> implements PolicyRuleFluent.LimitRangeAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeBuilder builder;
    
            LimitRangeAttributeRestrictionsNestedImpl(LimitRange item){
                    this.builder = new LimitRangeBuilder(this, item);
            }
            LimitRangeAttributeRestrictionsNestedImpl(){
                    this.builder = new LimitRangeBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withLimitRangeAttributeRestrictions(builder.build());
    }
    public N endLimitRangeAttributeRestrictions(){
            return and();
    }

}
    public class EndpointsAttributeRestrictionsNestedImpl extends EndpointsFluentImpl> implements PolicyRuleFluent.EndpointsAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsBuilder builder;
    
            EndpointsAttributeRestrictionsNestedImpl(Endpoints item){
                    this.builder = new EndpointsBuilder(this, item);
            }
            EndpointsAttributeRestrictionsNestedImpl(){
                    this.builder = new EndpointsBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withEndpointsAttributeRestrictions(builder.build());
    }
    public N endEndpointsAttributeRestrictions(){
            return and();
    }

}
    public class SecurityContextConstraintsAttributeRestrictionsNestedImpl extends SecurityContextConstraintsFluentImpl> implements PolicyRuleFluent.SecurityContextConstraintsAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecurityContextConstraintsBuilder builder;
    
            SecurityContextConstraintsAttributeRestrictionsNestedImpl(SecurityContextConstraints item){
                    this.builder = new SecurityContextConstraintsBuilder(this, item);
            }
            SecurityContextConstraintsAttributeRestrictionsNestedImpl(){
                    this.builder = new SecurityContextConstraintsBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withSecurityContextConstraintsAttributeRestrictions(builder.build());
    }
    public N endSecurityContextConstraintsAttributeRestrictions(){
            return and();
    }

}
    public class GroupAttributeRestrictionsNestedImpl extends GroupFluentImpl> implements PolicyRuleFluent.GroupAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final GroupBuilder builder;
    
            GroupAttributeRestrictionsNestedImpl(Group item){
                    this.builder = new GroupBuilder(this, item);
            }
            GroupAttributeRestrictionsNestedImpl(){
                    this.builder = new GroupBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withGroupAttributeRestrictions(builder.build());
    }
    public N endGroupAttributeRestrictions(){
            return and();
    }

}
    public class EventAttributeRestrictionsNestedImpl extends EventFluentImpl> implements PolicyRuleFluent.EventAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventBuilder builder;
    
            EventAttributeRestrictionsNestedImpl(Event item){
                    this.builder = new EventBuilder(this, item);
            }
            EventAttributeRestrictionsNestedImpl(){
                    this.builder = new EventBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withEventAttributeRestrictions(builder.build());
    }
    public N endEventAttributeRestrictions(){
            return and();
    }

}
    public class NodeAttributeRestrictionsNestedImpl extends NodeFluentImpl> implements PolicyRuleFluent.NodeAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeBuilder builder;
    
            NodeAttributeRestrictionsNestedImpl(Node item){
                    this.builder = new NodeBuilder(this, item);
            }
            NodeAttributeRestrictionsNestedImpl(){
                    this.builder = new NodeBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withNodeAttributeRestrictions(builder.build());
    }
    public N endNodeAttributeRestrictions(){
            return and();
    }

}
    public class ReplicaSetAttributeRestrictionsNestedImpl extends ReplicaSetFluentImpl> implements PolicyRuleFluent.ReplicaSetAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetBuilder builder;
    
            ReplicaSetAttributeRestrictionsNestedImpl(ReplicaSet item){
                    this.builder = new ReplicaSetBuilder(this, item);
            }
            ReplicaSetAttributeRestrictionsNestedImpl(){
                    this.builder = new ReplicaSetBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withReplicaSetAttributeRestrictions(builder.build());
    }
    public N endReplicaSetAttributeRestrictions(){
            return and();
    }

}
    public class ClusterRoleBindingAttributeRestrictionsNestedImpl extends ClusterRoleBindingFluentImpl> implements PolicyRuleFluent.ClusterRoleBindingAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterRoleBindingBuilder builder;
    
            ClusterRoleBindingAttributeRestrictionsNestedImpl(ClusterRoleBinding item){
                    this.builder = new ClusterRoleBindingBuilder(this, item);
            }
            ClusterRoleBindingAttributeRestrictionsNestedImpl(){
                    this.builder = new ClusterRoleBindingBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withClusterRoleBindingAttributeRestrictions(builder.build());
    }
    public N endClusterRoleBindingAttributeRestrictions(){
            return and();
    }

}
    public class JenkinsAttributeRestrictionsNestedImpl extends JenkinsFluentImpl> implements PolicyRuleFluent.JenkinsAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBuilder builder;
    
            JenkinsAttributeRestrictionsNestedImpl(Jenkins item){
                    this.builder = new JenkinsBuilder(this, item);
            }
            JenkinsAttributeRestrictionsNestedImpl(){
                    this.builder = new JenkinsBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withJenkinsAttributeRestrictions(builder.build());
    }
    public N endJenkinsAttributeRestrictions(){
            return and();
    }

}
    public class DaemonSetAttributeRestrictionsNestedImpl extends DaemonSetFluentImpl> implements PolicyRuleFluent.DaemonSetAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetBuilder builder;
    
            DaemonSetAttributeRestrictionsNestedImpl(DaemonSet item){
                    this.builder = new DaemonSetBuilder(this, item);
            }
            DaemonSetAttributeRestrictionsNestedImpl(){
                    this.builder = new DaemonSetBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withDaemonSetAttributeRestrictions(builder.build());
    }
    public N endDaemonSetAttributeRestrictions(){
            return and();
    }

}
    public class PodDisruptionBudgetAttributeRestrictionsNestedImpl extends PodDisruptionBudgetFluentImpl> implements PolicyRuleFluent.PodDisruptionBudgetAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetBuilder builder;
    
            PodDisruptionBudgetAttributeRestrictionsNestedImpl(PodDisruptionBudget item){
                    this.builder = new PodDisruptionBudgetBuilder(this, item);
            }
            PodDisruptionBudgetAttributeRestrictionsNestedImpl(){
                    this.builder = new PodDisruptionBudgetBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPodDisruptionBudgetAttributeRestrictions(builder.build());
    }
    public N endPodDisruptionBudgetAttributeRestrictions(){
            return and();
    }

}
    public class ImageStreamAttributeRestrictionsNestedImpl extends ImageStreamFluentImpl> implements PolicyRuleFluent.ImageStreamAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageStreamBuilder builder;
    
            ImageStreamAttributeRestrictionsNestedImpl(ImageStream item){
                    this.builder = new ImageStreamBuilder(this, item);
            }
            ImageStreamAttributeRestrictionsNestedImpl(){
                    this.builder = new ImageStreamBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withImageStreamAttributeRestrictions(builder.build());
    }
    public N endImageStreamAttributeRestrictions(){
            return and();
    }

}
    public class RoleBindingRestrictionAttributeRestrictionsNestedImpl extends RoleBindingRestrictionFluentImpl> implements PolicyRuleFluent.RoleBindingRestrictionAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingRestrictionBuilder builder;
    
            RoleBindingRestrictionAttributeRestrictionsNestedImpl(RoleBindingRestriction item){
                    this.builder = new RoleBindingRestrictionBuilder(this, item);
            }
            RoleBindingRestrictionAttributeRestrictionsNestedImpl(){
                    this.builder = new RoleBindingRestrictionBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withRoleBindingRestrictionAttributeRestrictions(builder.build());
    }
    public N endRoleBindingRestrictionAttributeRestrictions(){
            return and();
    }

}
    public class BindingAttributeRestrictionsNestedImpl extends BindingFluentImpl> implements PolicyRuleFluent.BindingAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final BindingBuilder builder;
    
            BindingAttributeRestrictionsNestedImpl(Binding item){
                    this.builder = new BindingBuilder(this, item);
            }
            BindingAttributeRestrictionsNestedImpl(){
                    this.builder = new BindingBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withBindingAttributeRestrictions(builder.build());
    }
    public N endBindingAttributeRestrictions(){
            return and();
    }

}
    public class AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNestedImpl extends io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewFluentImpl> implements PolicyRuleFluent.AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder builder;
    
            AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNestedImpl(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(this, item);
            }
            AuthorizationLocalSubjectAccessReviewAttributeRestrictionsNestedImpl(){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withLocalSubjectAccessReviewAttributeRestrictions(builder.build());
    }
    public N endAuthorizationLocalSubjectAccessReviewAttributeRestrictions(){
            return and();
    }

}
    public class StatefulSetAttributeRestrictionsNestedImpl extends StatefulSetFluentImpl> implements PolicyRuleFluent.StatefulSetAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetBuilder builder;
    
            StatefulSetAttributeRestrictionsNestedImpl(StatefulSet item){
                    this.builder = new StatefulSetBuilder(this, item);
            }
            StatefulSetAttributeRestrictionsNestedImpl(){
                    this.builder = new StatefulSetBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withStatefulSetAttributeRestrictions(builder.build());
    }
    public N endStatefulSetAttributeRestrictions(){
            return and();
    }

}
    public class PipelineTemplateTaskInstanceAttributeRestrictionsNestedImpl extends PipelineTemplateTaskInstanceFluentImpl> implements PolicyRuleFluent.PipelineTemplateTaskInstanceAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateTaskInstanceBuilder builder;
    
            PipelineTemplateTaskInstanceAttributeRestrictionsNestedImpl(PipelineTemplateTaskInstance item){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this, item);
            }
            PipelineTemplateTaskInstanceAttributeRestrictionsNestedImpl(){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPipelineTemplateTaskInstanceAttributeRestrictions(builder.build());
    }
    public N endPipelineTemplateTaskInstanceAttributeRestrictions(){
            return and();
    }

}
    public class OAuthClientAttributeRestrictionsNestedImpl extends OAuthClientFluentImpl> implements PolicyRuleFluent.OAuthClientAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientBuilder builder;
    
            OAuthClientAttributeRestrictionsNestedImpl(OAuthClient item){
                    this.builder = new OAuthClientBuilder(this, item);
            }
            OAuthClientAttributeRestrictionsNestedImpl(){
                    this.builder = new OAuthClientBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withOAuthClientAttributeRestrictions(builder.build());
    }
    public N endOAuthClientAttributeRestrictions(){
            return and();
    }

}
    public class TemplateAttributeRestrictionsNestedImpl extends TemplateFluentImpl> implements PolicyRuleFluent.TemplateAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final TemplateBuilder builder;
    
            TemplateAttributeRestrictionsNestedImpl(Template item){
                    this.builder = new TemplateBuilder(this, item);
            }
            TemplateAttributeRestrictionsNestedImpl(){
                    this.builder = new TemplateBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withTemplateAttributeRestrictions(builder.build());
    }
    public N endTemplateAttributeRestrictions(){
            return and();
    }

}
    public class BuildConfigAttributeRestrictionsNestedImpl extends BuildConfigFluentImpl> implements PolicyRuleFluent.BuildConfigAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildConfigBuilder builder;
    
            BuildConfigAttributeRestrictionsNestedImpl(BuildConfig item){
                    this.builder = new BuildConfigBuilder(this, item);
            }
            BuildConfigAttributeRestrictionsNestedImpl(){
                    this.builder = new BuildConfigBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withBuildConfigAttributeRestrictions(builder.build());
    }
    public N endBuildConfigAttributeRestrictions(){
            return and();
    }

}
    public class PodSecurityPolicyAttributeRestrictionsNestedImpl extends PodSecurityPolicyFluentImpl> implements PolicyRuleFluent.PodSecurityPolicyAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyBuilder builder;
    
            PodSecurityPolicyAttributeRestrictionsNestedImpl(PodSecurityPolicy item){
                    this.builder = new PodSecurityPolicyBuilder(this, item);
            }
            PodSecurityPolicyAttributeRestrictionsNestedImpl(){
                    this.builder = new PodSecurityPolicyBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPodSecurityPolicyAttributeRestrictions(builder.build());
    }
    public N endPodSecurityPolicyAttributeRestrictions(){
            return and();
    }

}
    public class PipelineAttributeRestrictionsNestedImpl extends PipelineFluentImpl> implements PolicyRuleFluent.PipelineAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineBuilder builder;
    
            PipelineAttributeRestrictionsNestedImpl(Pipeline item){
                    this.builder = new PipelineBuilder(this, item);
            }
            PipelineAttributeRestrictionsNestedImpl(){
                    this.builder = new PipelineBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPipelineAttributeRestrictions(builder.build());
    }
    public N endPipelineAttributeRestrictions(){
            return and();
    }

}
    public class RoleAttributeRestrictionsNestedImpl extends RoleFluentImpl> implements PolicyRuleFluent.RoleAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBuilder builder;
    
            RoleAttributeRestrictionsNestedImpl(Role item){
                    this.builder = new RoleBuilder(this, item);
            }
            RoleAttributeRestrictionsNestedImpl(){
                    this.builder = new RoleBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withRoleAttributeRestrictions(builder.build());
    }
    public N endRoleAttributeRestrictions(){
            return and();
    }

}
    public class CronJobAttributeRestrictionsNestedImpl extends CronJobFluentImpl> implements PolicyRuleFluent.CronJobAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobBuilder builder;
    
            CronJobAttributeRestrictionsNestedImpl(CronJob item){
                    this.builder = new CronJobBuilder(this, item);
            }
            CronJobAttributeRestrictionsNestedImpl(){
                    this.builder = new CronJobBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withCronJobAttributeRestrictions(builder.build());
    }
    public N endCronJobAttributeRestrictions(){
            return and();
    }

}
    public class UserAttributeRestrictionsNestedImpl extends UserFluentImpl> implements PolicyRuleFluent.UserAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final UserBuilder builder;
    
            UserAttributeRestrictionsNestedImpl(User item){
                    this.builder = new UserBuilder(this, item);
            }
            UserAttributeRestrictionsNestedImpl(){
                    this.builder = new UserBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withUserAttributeRestrictions(builder.build());
    }
    public N endUserAttributeRestrictions(){
            return and();
    }

}
    public class AuthorizationSubjectAccessReviewAttributeRestrictionsNestedImpl extends io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewFluentImpl> implements PolicyRuleFluent.AuthorizationSubjectAccessReviewAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder builder;
    
            AuthorizationSubjectAccessReviewAttributeRestrictionsNestedImpl(io.alauda.kubernetes.api.model.authorization.SubjectAccessReview item){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder(this, item);
            }
            AuthorizationSubjectAccessReviewAttributeRestrictionsNestedImpl(){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withSubjectAccessReviewAttributeRestrictions(builder.build());
    }
    public N endAuthorizationSubjectAccessReviewAttributeRestrictions(){
            return and();
    }

}
    public class StorageClassAttributeRestrictionsNestedImpl extends StorageClassFluentImpl> implements PolicyRuleFluent.StorageClassAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassBuilder builder;
    
            StorageClassAttributeRestrictionsNestedImpl(StorageClass item){
                    this.builder = new StorageClassBuilder(this, item);
            }
            StorageClassAttributeRestrictionsNestedImpl(){
                    this.builder = new StorageClassBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withStorageClassAttributeRestrictions(builder.build());
    }
    public N endStorageClassAttributeRestrictions(){
            return and();
    }

}
    public class PipelineConfigTemplateAttributeRestrictionsNestedImpl extends PipelineConfigTemplateFluentImpl> implements PolicyRuleFluent.PipelineConfigTemplateAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigTemplateBuilder builder;
    
            PipelineConfigTemplateAttributeRestrictionsNestedImpl(PipelineConfigTemplate item){
                    this.builder = new PipelineConfigTemplateBuilder(this, item);
            }
            PipelineConfigTemplateAttributeRestrictionsNestedImpl(){
                    this.builder = new PipelineConfigTemplateBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPipelineConfigTemplateAttributeRestrictions(builder.build());
    }
    public N endPipelineConfigTemplateAttributeRestrictions(){
            return and();
    }

}
    public class PipelineConfigAttributeRestrictionsNestedImpl extends PipelineConfigFluentImpl> implements PolicyRuleFluent.PipelineConfigAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigBuilder builder;
    
            PipelineConfigAttributeRestrictionsNestedImpl(PipelineConfig item){
                    this.builder = new PipelineConfigBuilder(this, item);
            }
            PipelineConfigAttributeRestrictionsNestedImpl(){
                    this.builder = new PipelineConfigBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPipelineConfigAttributeRestrictions(builder.build());
    }
    public N endPipelineConfigAttributeRestrictions(){
            return and();
    }

}
    public class DeploymentConfigAttributeRestrictionsNestedImpl extends DeploymentConfigFluentImpl> implements PolicyRuleFluent.DeploymentConfigAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentConfigBuilder builder;
    
            DeploymentConfigAttributeRestrictionsNestedImpl(DeploymentConfig item){
                    this.builder = new DeploymentConfigBuilder(this, item);
            }
            DeploymentConfigAttributeRestrictionsNestedImpl(){
                    this.builder = new DeploymentConfigBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withDeploymentConfigAttributeRestrictions(builder.build());
    }
    public N endDeploymentConfigAttributeRestrictions(){
            return and();
    }

}
    public class OAuthAccessTokenAttributeRestrictionsNestedImpl extends OAuthAccessTokenFluentImpl> implements PolicyRuleFluent.OAuthAccessTokenAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAccessTokenBuilder builder;
    
            OAuthAccessTokenAttributeRestrictionsNestedImpl(OAuthAccessToken item){
                    this.builder = new OAuthAccessTokenBuilder(this, item);
            }
            OAuthAccessTokenAttributeRestrictionsNestedImpl(){
                    this.builder = new OAuthAccessTokenBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withOAuthAccessTokenAttributeRestrictions(builder.build());
    }
    public N endOAuthAccessTokenAttributeRestrictions(){
            return and();
    }

}
    public class PersistentVolumeClaimAttributeRestrictionsNestedImpl extends PersistentVolumeClaimFluentImpl> implements PolicyRuleFluent.PersistentVolumeClaimAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimBuilder builder;
    
            PersistentVolumeClaimAttributeRestrictionsNestedImpl(PersistentVolumeClaim item){
                    this.builder = new PersistentVolumeClaimBuilder(this, item);
            }
            PersistentVolumeClaimAttributeRestrictionsNestedImpl(){
                    this.builder = new PersistentVolumeClaimBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPersistentVolumeClaimAttributeRestrictions(builder.build());
    }
    public N endPersistentVolumeClaimAttributeRestrictions(){
            return and();
    }

}
    public class NetworkPolicyAttributeRestrictionsNestedImpl extends NetworkPolicyFluentImpl> implements PolicyRuleFluent.NetworkPolicyAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyBuilder builder;
    
            NetworkPolicyAttributeRestrictionsNestedImpl(NetworkPolicy item){
                    this.builder = new NetworkPolicyBuilder(this, item);
            }
            NetworkPolicyAttributeRestrictionsNestedImpl(){
                    this.builder = new NetworkPolicyBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withNetworkPolicyAttributeRestrictions(builder.build());
    }
    public N endNetworkPolicyAttributeRestrictions(){
            return and();
    }

}
    public class ImageAttributeRestrictionsNestedImpl extends ImageFluentImpl> implements PolicyRuleFluent.ImageAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageBuilder builder;
    
            ImageAttributeRestrictionsNestedImpl(Image item){
                    this.builder = new ImageBuilder(this, item);
            }
            ImageAttributeRestrictionsNestedImpl(){
                    this.builder = new ImageBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withImageAttributeRestrictions(builder.build());
    }
    public N endImageAttributeRestrictions(){
            return and();
    }

}
    public class ServiceAttributeRestrictionsNestedImpl extends ServiceFluentImpl> implements PolicyRuleFluent.ServiceAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceBuilder builder;
    
            ServiceAttributeRestrictionsNestedImpl(Service item){
                    this.builder = new ServiceBuilder(this, item);
            }
            ServiceAttributeRestrictionsNestedImpl(){
                    this.builder = new ServiceBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withServiceAttributeRestrictions(builder.build());
    }
    public N endServiceAttributeRestrictions(){
            return and();
    }

}
    public class JobAttributeRestrictionsNestedImpl extends JobFluentImpl> implements PolicyRuleFluent.JobAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobBuilder builder;
    
            JobAttributeRestrictionsNestedImpl(Job item){
                    this.builder = new JobBuilder(this, item);
            }
            JobAttributeRestrictionsNestedImpl(){
                    this.builder = new JobBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withJobAttributeRestrictions(builder.build());
    }
    public N endJobAttributeRestrictions(){
            return and();
    }

}
    public class DeploymentAttributeRestrictionsNestedImpl extends DeploymentFluentImpl> implements PolicyRuleFluent.DeploymentAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentBuilder builder;
    
            DeploymentAttributeRestrictionsNestedImpl(Deployment item){
                    this.builder = new DeploymentBuilder(this, item);
            }
            DeploymentAttributeRestrictionsNestedImpl(){
                    this.builder = new DeploymentBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withDeploymentAttributeRestrictions(builder.build());
    }
    public N endDeploymentAttributeRestrictions(){
            return and();
    }

}
    public class ClusterPolicyBindingAttributeRestrictionsNestedImpl extends ClusterPolicyBindingFluentImpl> implements PolicyRuleFluent.ClusterPolicyBindingAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBindingBuilder builder;
    
            ClusterPolicyBindingAttributeRestrictionsNestedImpl(ClusterPolicyBinding item){
                    this.builder = new ClusterPolicyBindingBuilder(this, item);
            }
            ClusterPolicyBindingAttributeRestrictionsNestedImpl(){
                    this.builder = new ClusterPolicyBindingBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withClusterPolicyBindingAttributeRestrictions(builder.build());
    }
    public N endClusterPolicyBindingAttributeRestrictions(){
            return and();
    }

}
    public class ProjectAttributeRestrictionsNestedImpl extends ProjectFluentImpl> implements PolicyRuleFluent.ProjectAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectBuilder builder;
    
            ProjectAttributeRestrictionsNestedImpl(Project item){
                    this.builder = new ProjectBuilder(this, item);
            }
            ProjectAttributeRestrictionsNestedImpl(){
                    this.builder = new ProjectBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withProjectAttributeRestrictions(builder.build());
    }
    public N endProjectAttributeRestrictions(){
            return and();
    }

}
    public class BuildRequestAttributeRestrictionsNestedImpl extends BuildRequestFluentImpl> implements PolicyRuleFluent.BuildRequestAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildRequestBuilder builder;
    
            BuildRequestAttributeRestrictionsNestedImpl(BuildRequest item){
                    this.builder = new BuildRequestBuilder(this, item);
            }
            BuildRequestAttributeRestrictionsNestedImpl(){
                    this.builder = new BuildRequestBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withBuildRequestAttributeRestrictions(builder.build());
    }
    public N endBuildRequestAttributeRestrictions(){
            return and();
    }

}
    public class RoleBindingAttributeRestrictionsNestedImpl extends RoleBindingFluentImpl> implements PolicyRuleFluent.RoleBindingAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingBuilder builder;
    
            RoleBindingAttributeRestrictionsNestedImpl(RoleBinding item){
                    this.builder = new RoleBindingBuilder(this, item);
            }
            RoleBindingAttributeRestrictionsNestedImpl(){
                    this.builder = new RoleBindingBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withRoleBindingAttributeRestrictions(builder.build());
    }
    public N endRoleBindingAttributeRestrictions(){
            return and();
    }

}
    public class PersistentVolumeAttributeRestrictionsNestedImpl extends PersistentVolumeFluentImpl> implements PolicyRuleFluent.PersistentVolumeAttributeRestrictionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeBuilder builder;
    
            PersistentVolumeAttributeRestrictionsNestedImpl(PersistentVolume item){
                    this.builder = new PersistentVolumeBuilder(this, item);
            }
            PersistentVolumeAttributeRestrictionsNestedImpl(){
                    this.builder = new PersistentVolumeBuilder(this);
            }
    
    public N and(){
            return (N) PolicyRuleFluentImpl.this.withPersistentVolumeAttributeRestrictions(builder.build());
    }
    public N endPersistentVolumeAttributeRestrictions(){
            return and();
    }

}


}
Related Artifacts