• Home
• io.alauda
• kubernetes-model
• 0.2.4.3
• source code
• KubeSchemaFluentImpl.java

×

Project download

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

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

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

package io.alauda.kubernetes.api.model;

import io.alauda.devops.api.model.DeploymentConfigBuilder;
import io.alauda.devops.api.model.IdentityList;
import java.lang.String;
import io.alauda.devops.api.model.OAuthAccessTokenBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetListBuilder;
import io.alauda.devops.api.model.OAuthAccessTokenFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionFluentImpl;
import com.fasterxml.jackson.databind.SerializerProvider;
import io.alauda.devops.api.model.SecurityContextConstraintsListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatusBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionCondition;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionList;
import io.alauda.devops.api.model.BuildConfigListBuilder;
import io.alauda.devops.api.model.SubjectAccessReviewBuilder;
import io.alauda.devops.api.model.OAuthAccessToken;
import io.alauda.devops.api.model.DeploymentConfig;
import io.alauda.devops.api.model.PolicyBindingListBuilder;
import io.alauda.devops.api.model.OAuthClientBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyList;
import io.alauda.devops.api.model.BuildRequestFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetList;
import java.lang.Deprecated;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicy;
import io.alauda.devops.api.model.OAuthAccessTokenListFluentImpl;
import io.alauda.devops.api.model.TagEventFluentImpl;
import io.alauda.devops.api.model.ClusterPolicyBindingListFluentImpl;
import io.alauda.devops.api.model.SecurityContextConstraints;
import io.alauda.devops.api.model.ClusterRoleBindingListFluentImpl;
import io.alauda.devops.api.model.OAuthAuthorizeTokenBuilder;
import io.alauda.devops.api.model.OAuthClientAuthorizationListFluentImpl;
import io.alauda.devops.api.model.IdentityListFluentImpl;
import io.alauda.devops.api.model.LocalSubjectAccessReviewBuilder;
import io.alauda.devops.api.model.RoleBindingList;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollbackFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyList;
import io.alauda.kubernetes.api.model.extensions.ScaleFluentImpl;
import io.alauda.kubernetes.api.model.extensions.Deployment;
import io.alauda.devops.api.model.GroupListBuilder;
import io.alauda.devops.api.model.GroupList;
import java.lang.Override;
import io.alauda.devops.api.model.SecurityContextConstraintsFluentImpl;
import io.alauda.devops.api.model.BuildListBuilder;
import io.alauda.devops.api.model.ClusterRoleBindingBuilder;
import io.alauda.devops.api.model.ClusterPolicyListFluentImpl;
import io.alauda.devops.api.model.ClusterPolicyBindingFluentImpl;
import io.alauda.devops.api.model.OAuthAuthorizeToken;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceFluentImpl;
import io.alauda.devops.api.model.Role;
import io.alauda.devops.api.model.BuildConfigListFluentImpl;
import io.alauda.devops.api.model.OAuthClientAuthorizationBuilder;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetListBuilder;
import io.alauda.devops.api.model.RoleListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressList;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionListFluentImpl;
import io.alauda.devops.api.model.ClusterRoleBindingFluentImpl;
import io.alauda.devops.api.model.PolicyList;
import io.alauda.devops.api.model.UserList;
import com.fasterxml.jackson.core.JsonParser;
import io.alauda.devops.api.model.RoleBindingListFluentImpl;
import io.alauda.devops.api.model.ClusterPolicyBindingList;
import io.alauda.devops.api.model.TemplateListFluentImpl;
import io.alauda.devops.api.model.SecurityContextConstraintsList;
import io.alauda.kubernetes.api.model.version.Info;
import io.alauda.devops.api.model.LocalSubjectAccessReview;
import io.alauda.devops.api.model.RoleBuilder;
import io.alauda.devops.api.model.ImageListFluentImpl;
import io.alauda.devops.api.model.BuildListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionConditionBuilder;
import io.alauda.devops.api.model.SecurityContextConstraintsBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetList;
import io.alauda.devops.api.model.OAuthClientAuthorizationFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicy;
import io.alauda.devops.api.model.RoleListBuilder;
import io.alauda.devops.api.model.RouteListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNamesFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentBuilder;
import io.alauda.devops.api.model.ImageListBuilder;
import io.alauda.kubernetes.api.model.version.InfoBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResource;
import io.alauda.devops.api.model.TagEventBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpec;
import io.alauda.kubernetes.api.model.authentication.TokenReviewBuilder;
import io.alauda.devops.api.model.RoleBindingRestrictionFluentImpl;
import io.alauda.devops.api.model.RoleBindingRestriction;
import io.alauda.devops.api.model.OAuthClientAuthorizationListBuilder;
import io.alauda.devops.api.model.ClusterPolicyBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyListBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollbackBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyListFluentImpl;
import io.alauda.devops.api.model.ClusterRoleBindingList;
import io.alauda.kubernetes.api.model.authentication.TokenReview;
import io.alauda.devops.api.model.OAuthAccessTokenList;
import io.alauda.devops.api.model.ImageStreamTagListFluentImpl;
import io.alauda.devops.api.model.DeploymentConfigListBuilder;
import io.alauda.devops.api.model.SecurityContextConstraintsListBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionBuilder;
import io.alauda.devops.api.model.GroupFluentImpl;
import io.alauda.devops.api.model.TemplateBuilder;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetBuilder;
import io.alauda.devops.api.model.Template;
import io.alauda.devops.api.model.OAuthAuthorizeTokenList;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceBuilder;
import io.alauda.devops.api.model.ClusterPolicyBindingBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyFluentImpl;
import io.alauda.kubernetes.api.model.version.InfoFluentImpl;
import io.alauda.devops.api.model.RoleList;
import io.alauda.devops.api.model.OAuthClientListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.Ingress;
import io.alauda.devops.api.model.IdentityBuilder;
import io.alauda.devops.api.model.ImageStreamListFluentImpl;
import io.alauda.devops.api.model.DeploymentConfigListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpecFluentImpl;
import io.alauda.devops.api.model.OAuthClient;
import io.alauda.kubernetes.api.model.extensions.DaemonSetBuilder;
import io.alauda.devops.api.model.OAuthClientAuthorizationList;
import com.fasterxml.jackson.databind.DeserializationContext;
import io.alauda.devops.api.model.ClusterRoleBindingListBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollback;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinition;
import io.alauda.devops.api.model.OAuthAuthorizeTokenListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.Scale;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyBuilder;
import io.alauda.devops.api.model.PolicyBindingList;
import io.alauda.devops.api.model.SubjectAccessReviewResponse;
import io.alauda.devops.api.model.ClusterRoleBinding;
import io.alauda.devops.api.model.UserBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyBuilder;
import io.alauda.devops.api.model.PolicyBindingBuilder;
import io.alauda.devops.api.model.OAuthClientAuthorization;
import io.alauda.devops.api.model.Group;
import io.alauda.devops.api.model.RouteListBuilder;
import io.alauda.devops.api.model.RouteBuilder;
import io.alauda.devops.api.model.SubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.StatefulSetBuilder;
import io.alauda.devops.api.model.IdentityFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentListBuilder;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetList;
import io.alauda.kubernetes.api.model.extensions.ReplicaSet;
import io.alauda.devops.api.model.SubjectAccessReviewResponseFluentImpl;
import io.alauda.devops.api.model.SubjectAccessReviewFluentImpl;
import io.alauda.kubernetes.api.model.authentication.TokenReviewFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetFluentImpl;
import io.alauda.devops.api.model.GroupBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionConditionFluentImpl;
import io.alauda.devops.api.model.UserListFluentImpl;
import io.alauda.devops.api.model.IdentityListBuilder;
import io.alauda.devops.api.model.Route;
import io.alauda.devops.api.model.RouteFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressListBuilder;
import io.alauda.devops.api.model.OAuthAuthorizeTokenListBuilder;
import java.lang.Long;
import io.alauda.devops.api.model.ClusterPolicyBindingListBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSet;
import io.alauda.devops.api.model.BuildConfigList;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyListFluentImpl;
import com.fasterxml.jackson.databind.JsonSerializer;
import io.alauda.kubernetes.api.model.extensions.DaemonSetListBuilder;
import io.alauda.devops.api.model.OAuthClientList;
import io.alauda.devops.api.model.DeploymentConfigList;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyFluentImpl;
import io.alauda.devops.api.model.PolicyBinding;
import io.alauda.kubernetes.api.model.extensions.IngressBuilder;
import io.alauda.devops.api.model.UserFluentImpl;
import io.alauda.devops.api.model.ClusterPolicyFluentImpl;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.alauda.devops.api.model.RouteList;
import com.fasterxml.jackson.databind.JsonDeserializer;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyListBuilder;
import io.alauda.devops.api.model.BuildRequestBuilder;
import io.alauda.kubernetes.api.builder.BaseFluent;
import io.alauda.devops.api.model.Identity;
import java.lang.Boolean;
import io.alauda.devops.api.model.UserListBuilder;
import io.alauda.devops.api.model.ClusterPolicyListBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNamesBuilder;
import io.alauda.devops.api.model.ImageStreamList;
import io.alauda.devops.api.model.PolicyListBuilder;
import io.alauda.devops.api.model.RoleBindingRestrictionBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetFluentImpl;
import io.alauda.devops.api.model.PolicyListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetList;
import javax.validation.Valid;
import io.alauda.kubernetes.api.model.extensions.DeploymentListFluentImpl;
import java.lang.Object;
import io.alauda.devops.api.model.OAuthAccessTokenListBuilder;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceListBuilder;
import io.alauda.devops.api.model.PolicyBindingFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpecBuilder;
import io.alauda.devops.api.model.ImageStreamTagList;
import io.alauda.devops.api.model.TemplateFluentImpl;
import io.alauda.devops.api.model.DeploymentConfigFluentImpl;
import io.alauda.devops.api.model.TemplateListBuilder;
import com.fasterxml.jackson.core.JsonGenerator;
import io.alauda.devops.api.model.RoleBindingListBuilder;
import io.alauda.devops.api.model.ClusterPolicy;
import io.alauda.devops.api.model.RoleFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSetListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSetListBuilder;
import io.alauda.devops.api.model.ImageList;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionListBuilder;
import io.alauda.devops.api.model.OAuthAuthorizeTokenFluentImpl;
import io.alauda.devops.api.model.Policy;
import io.alauda.devops.api.model.SubjectAccessReviewResponseBuilder;
import io.alauda.devops.api.model.LocalSubjectAccessReviewFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatus;
import io.alauda.kubernetes.api.model.extensions.DeploymentFluentImpl;
import io.alauda.devops.api.model.ClusterPolicyList;
import io.alauda.devops.api.model.RoleBinding;
import io.alauda.devops.api.model.PolicyBuilder;
import io.alauda.kubernetes.api.model.extensions.ScaleBuilder;
import io.alauda.devops.api.model.GroupListFluentImpl;
import io.alauda.devops.api.model.ImageStreamListBuilder;
import io.alauda.devops.api.model.RoleBindingBuilder;
import io.alauda.devops.api.model.TagEvent;
import io.alauda.devops.api.model.BuildRequest;
import io.alauda.devops.api.model.OAuthClientFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSet;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceListFluentImpl;
import io.alauda.devops.api.model.PolicyBindingListFluentImpl;
import io.alauda.devops.api.model.TemplateList;
import io.alauda.devops.api.model.User;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudget;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetListFluentImpl;
import io.alauda.kubernetes.api.builder.Nested;
import io.alauda.kubernetes.api.model.extensions.DeploymentList;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceList;
import io.alauda.devops.api.model.ClusterPolicyBinding;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNames;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetBuilder;
import io.alauda.devops.api.model.BuildList;
import io.alauda.devops.api.model.OAuthClientListBuilder;
import io.alauda.devops.api.model.RoleBindingFluentImpl;
import io.alauda.devops.api.model.PolicyFluentImpl;
import io.alauda.devops.api.model.ImageStreamTagListBuilder;

public class KubeSchemaFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements KubeSchemaFluent{

    private BaseKubernetesListBuilder baseKubernetesList;
    private BindingBuilder binding;
    private BuildConfigListBuilder buildConfigList;
    private BuildListBuilder buildList;
    private BuildRequestBuilder buildRequest;
    private ClusterPolicyBuilder clusterPolicy;
    private ClusterPolicyBindingBuilder clusterPolicyBinding;
    private ClusterPolicyBindingListBuilder clusterPolicyBindingList;
    private ClusterPolicyListBuilder clusterPolicyList;
    private ClusterRoleBindingBuilder clusterRoleBinding;
    private ClusterRoleBindingListBuilder clusterRoleBindingList;
    private ComponentStatusListBuilder componentStatusList;
    private ConfigBuilder config;
    private ConfigMapBuilder configMap;
    private ConfigMapListBuilder configMapList;
    private ContainerStatusBuilder containerStatus;
    private CronJobBuilder cronJob;
    private CronJobListBuilder cronJobList;
    private CustomResourceDefinitionBuilder customResourceDefinition;
    private CustomResourceDefinitionConditionBuilder customResourceDefinitionCondition;
    private CustomResourceDefinitionListBuilder customResourceDefinitionList;
    private CustomResourceDefinitionNamesBuilder customResourceDefinitionNames;
    private CustomResourceDefinitionSpecBuilder customResourceDefinitionSpec;
    private CustomResourceDefinitionStatusBuilder customResourceDefinitionStatus;
    private DaemonSetBuilder daemonSet;
    private DaemonSetListBuilder daemonSetList;
    private DeleteOptionsBuilder deleteOptions;
    private DeploymentBuilder deployment;
    private DeploymentConfigBuilder deploymentConfig;
    private DeploymentConfigListBuilder deploymentConfigList;
    private DeploymentListBuilder deploymentList;
    private DeploymentRollbackBuilder deploymentRollback;
    private EndpointsBuilder endpoints;
    private EndpointsListBuilder endpointsList;
    private EnvVarBuilder envVar;
    private EventListBuilder eventList;
    private GroupBuilder group;
    private GroupListBuilder groupList;
    private HorizontalPodAutoscalerBuilder horizontalPodAutoscaler;
    private HorizontalPodAutoscalerListBuilder horizontalPodAutoscalerList;
    private IdentityBuilder identity;
    private IdentityListBuilder identityList;
    private ImageListBuilder imageList;
    private ImageStreamListBuilder imageStreamList;
    private ImageStreamTagListBuilder imageStreamTagList;
    private InfoBuilder info;
    private IngressBuilder ingress;
    private IngressListBuilder ingressList;
    private JenkinsBuilder jenkins;
    private JenkinsBindingBuilder jenkinsBinding;
    private JenkinsBindingListBuilder jenkinsBindingList;
    private JenkinsListBuilder jenkinsList;
    private JobBuilder job;
    private JobListBuilder jobList;
    private io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder k8sLocalSubjectAccessReview;
    private io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder k8sSubjectAccessReview;
    private LimitRangeListBuilder limitRangeList;
    private ListMetaBuilder listMeta;
    private LocalSubjectAccessReviewBuilder localSubjectAccessReview;
    private NamespaceBuilder namespace;
    private NamespaceListBuilder namespaceList;
    private NetworkPolicyBuilder networkPolicy;
    private NetworkPolicyListBuilder networkPolicyList;
    private NodeBuilder node;
    private NodeListBuilder nodeList;
    private OAuthAccessTokenBuilder oAuthAccessToken;
    private OAuthAccessTokenListBuilder oAuthAccessTokenList;
    private OAuthAuthorizeTokenBuilder oAuthAuthorizeToken;
    private OAuthAuthorizeTokenListBuilder oAuthAuthorizeTokenList;
    private OAuthClientBuilder oAuthClient;
    private OAuthClientAuthorizationBuilder oAuthClientAuthorization;
    private OAuthClientAuthorizationListBuilder oAuthClientAuthorizationList;
    private OAuthClientListBuilder oAuthClientList;
    private ObjectMetaBuilder objectMeta;
    private PatchBuilder patch;
    private PersistentVolumeBuilder persistentVolume;
    private PersistentVolumeClaimBuilder persistentVolumeClaim;
    private PersistentVolumeClaimListBuilder persistentVolumeClaimList;
    private PersistentVolumeListBuilder persistentVolumeList;
    private PipelineBuilder pipeline;
    private PipelineConfigBuilder pipelineConfig;
    private PipelineConfigListBuilder pipelineConfigList;
    private PipelineListBuilder pipelineList;
    private PodDisruptionBudgetBuilder podDisruptionBudget;
    private PodDisruptionBudgetListBuilder podDisruptionBudgetList;
    private PodListBuilder podList;
    private PodSecurityPolicyBuilder podSecurityPolicy;
    private PodSecurityPolicyListBuilder podSecurityPolicyList;
    private PodTemplateListBuilder podTemplateList;
    private PolicyBuilder policy;
    private PolicyBindingBuilder policyBinding;
    private PolicyBindingListBuilder policyBindingList;
    private PolicyListBuilder policyList;
    private ProjectBuilder project;
    private ProjectListBuilder projectList;
    private QuantityBuilder quantity;
    private ReplicaSetBuilder replicaSet;
    private ReplicaSetListBuilder replicaSetList;
    private ReplicationControllerListBuilder replicationControllerList;
    private ResourceQuotaBuilder resourceQuota;
    private ResourceQuotaListBuilder resourceQuotaList;
    private RoleBuilder role;
    private RoleBindingBuilder roleBinding;
    private RoleBindingListBuilder roleBindingList;
    private RoleBindingRestrictionBuilder roleBindingRestriction;
    private RoleListBuilder roleList;
    private RootPathsBuilder rootPaths;
    private RouteBuilder route;
    private RouteListBuilder routeList;
    private ScaleBuilder scale;
    private SecretBuilder secret;
    private SecretListBuilder secretList;
    private SecurityContextConstraintsBuilder securityContextConstraints;
    private SecurityContextConstraintsListBuilder securityContextConstraintsList;
    private ServiceAccountBuilder serviceAccount;
    private ServiceAccountListBuilder serviceAccountList;
    private ServiceListBuilder serviceList;
    private StatefulSetBuilder statefulSet;
    private StatefulSetListBuilder statefulSetList;
    private StatusBuilder status;
    private StorageClassBuilder storageClass;
    private StorageClassListBuilder storageClassList;
    private SubjectAccessReviewBuilder subjectAccessReview;
    private SubjectAccessReviewResponseBuilder subjectAccessReviewResponse;
    private TagEventBuilder tagEvent;
    private TemplateBuilder template;
    private TemplateListBuilder templateList;
    private ThirdPartyResourceBuilder thirdPartyResource;
    private ThirdPartyResourceListBuilder thirdPartyResourceList;
    private TokenReviewBuilder tokenReview;
    private TolerationBuilder toleration;
    private UserBuilder user;
    private UserListBuilder userList;
    private WatchEventBuilder watchEvent;

    public KubeSchemaFluentImpl(){
    }
    public KubeSchemaFluentImpl(KubeSchema instance){
            this.withBaseKubernetesList(instance.getBaseKubernetesList()); 
            this.withBinding(instance.getBinding()); 
            this.withBuildConfigList(instance.getBuildConfigList()); 
            this.withBuildList(instance.getBuildList()); 
            this.withBuildRequest(instance.getBuildRequest()); 
            this.withClusterPolicy(instance.getClusterPolicy()); 
            this.withClusterPolicyBinding(instance.getClusterPolicyBinding()); 
            this.withClusterPolicyBindingList(instance.getClusterPolicyBindingList()); 
            this.withClusterPolicyList(instance.getClusterPolicyList()); 
            this.withClusterRoleBinding(instance.getClusterRoleBinding()); 
            this.withClusterRoleBindingList(instance.getClusterRoleBindingList()); 
            this.withComponentStatusList(instance.getComponentStatusList()); 
            this.withConfig(instance.getConfig()); 
            this.withConfigMap(instance.getConfigMap()); 
            this.withConfigMapList(instance.getConfigMapList()); 
            this.withContainerStatus(instance.getContainerStatus()); 
            this.withCronJob(instance.getCronJob()); 
            this.withCronJobList(instance.getCronJobList()); 
            this.withCustomResourceDefinition(instance.getCustomResourceDefinition()); 
            this.withCustomResourceDefinitionCondition(instance.getCustomResourceDefinitionCondition()); 
            this.withCustomResourceDefinitionList(instance.getCustomResourceDefinitionList()); 
            this.withCustomResourceDefinitionNames(instance.getCustomResourceDefinitionNames()); 
            this.withCustomResourceDefinitionSpec(instance.getCustomResourceDefinitionSpec()); 
            this.withCustomResourceDefinitionStatus(instance.getCustomResourceDefinitionStatus()); 
            this.withDaemonSet(instance.getDaemonSet()); 
            this.withDaemonSetList(instance.getDaemonSetList()); 
            this.withDeleteOptions(instance.getDeleteOptions()); 
            this.withDeployment(instance.getDeployment()); 
            this.withDeploymentConfig(instance.getDeploymentConfig()); 
            this.withDeploymentConfigList(instance.getDeploymentConfigList()); 
            this.withDeploymentList(instance.getDeploymentList()); 
            this.withDeploymentRollback(instance.getDeploymentRollback()); 
            this.withEndpoints(instance.getEndpoints()); 
            this.withEndpointsList(instance.getEndpointsList()); 
            this.withEnvVar(instance.getEnvVar()); 
            this.withEventList(instance.getEventList()); 
            this.withGroup(instance.getGroup()); 
            this.withGroupList(instance.getGroupList()); 
            this.withHorizontalPodAutoscaler(instance.getHorizontalPodAutoscaler()); 
            this.withHorizontalPodAutoscalerList(instance.getHorizontalPodAutoscalerList()); 
            this.withIdentity(instance.getIdentity()); 
            this.withIdentityList(instance.getIdentityList()); 
            this.withImageList(instance.getImageList()); 
            this.withImageStreamList(instance.getImageStreamList()); 
            this.withImageStreamTagList(instance.getImageStreamTagList()); 
            this.withInfo(instance.getInfo()); 
            this.withIngress(instance.getIngress()); 
            this.withIngressList(instance.getIngressList()); 
            this.withJenkins(instance.getJenkins()); 
            this.withJenkinsBinding(instance.getJenkinsBinding()); 
            this.withJenkinsBindingList(instance.getJenkinsBindingList()); 
            this.withJenkinsList(instance.getJenkinsList()); 
            this.withJob(instance.getJob()); 
            this.withJobList(instance.getJobList()); 
            this.withK8sLocalSubjectAccessReview(instance.getK8sLocalSubjectAccessReview()); 
            this.withK8sSubjectAccessReview(instance.getK8sSubjectAccessReview()); 
            this.withLimitRangeList(instance.getLimitRangeList()); 
            this.withListMeta(instance.getListMeta()); 
            this.withLocalSubjectAccessReview(instance.getLocalSubjectAccessReview()); 
            this.withNamespace(instance.getNamespace()); 
            this.withNamespaceList(instance.getNamespaceList()); 
            this.withNetworkPolicy(instance.getNetworkPolicy()); 
            this.withNetworkPolicyList(instance.getNetworkPolicyList()); 
            this.withNode(instance.getNode()); 
            this.withNodeList(instance.getNodeList()); 
            this.withOAuthAccessToken(instance.getOAuthAccessToken()); 
            this.withOAuthAccessTokenList(instance.getOAuthAccessTokenList()); 
            this.withOAuthAuthorizeToken(instance.getOAuthAuthorizeToken()); 
            this.withOAuthAuthorizeTokenList(instance.getOAuthAuthorizeTokenList()); 
            this.withOAuthClient(instance.getOAuthClient()); 
            this.withOAuthClientAuthorization(instance.getOAuthClientAuthorization()); 
            this.withOAuthClientAuthorizationList(instance.getOAuthClientAuthorizationList()); 
            this.withOAuthClientList(instance.getOAuthClientList()); 
            this.withObjectMeta(instance.getObjectMeta()); 
            this.withPatch(instance.getPatch()); 
            this.withPersistentVolume(instance.getPersistentVolume()); 
            this.withPersistentVolumeClaim(instance.getPersistentVolumeClaim()); 
            this.withPersistentVolumeClaimList(instance.getPersistentVolumeClaimList()); 
            this.withPersistentVolumeList(instance.getPersistentVolumeList()); 
            this.withPipeline(instance.getPipeline()); 
            this.withPipelineConfig(instance.getPipelineConfig()); 
            this.withPipelineConfigList(instance.getPipelineConfigList()); 
            this.withPipelineList(instance.getPipelineList()); 
            this.withPodDisruptionBudget(instance.getPodDisruptionBudget()); 
            this.withPodDisruptionBudgetList(instance.getPodDisruptionBudgetList()); 
            this.withPodList(instance.getPodList()); 
            this.withPodSecurityPolicy(instance.getPodSecurityPolicy()); 
            this.withPodSecurityPolicyList(instance.getPodSecurityPolicyList()); 
            this.withPodTemplateList(instance.getPodTemplateList()); 
            this.withPolicy(instance.getPolicy()); 
            this.withPolicyBinding(instance.getPolicyBinding()); 
            this.withPolicyBindingList(instance.getPolicyBindingList()); 
            this.withPolicyList(instance.getPolicyList()); 
            this.withProject(instance.getProject()); 
            this.withProjectList(instance.getProjectList()); 
            this.withQuantity(instance.getQuantity()); 
            this.withReplicaSet(instance.getReplicaSet()); 
            this.withReplicaSetList(instance.getReplicaSetList()); 
            this.withReplicationControllerList(instance.getReplicationControllerList()); 
            this.withResourceQuota(instance.getResourceQuota()); 
            this.withResourceQuotaList(instance.getResourceQuotaList()); 
            this.withRole(instance.getRole()); 
            this.withRoleBinding(instance.getRoleBinding()); 
            this.withRoleBindingList(instance.getRoleBindingList()); 
            this.withRoleBindingRestriction(instance.getRoleBindingRestriction()); 
            this.withRoleList(instance.getRoleList()); 
            this.withRootPaths(instance.getRootPaths()); 
            this.withRoute(instance.getRoute()); 
            this.withRouteList(instance.getRouteList()); 
            this.withScale(instance.getScale()); 
            this.withSecret(instance.getSecret()); 
            this.withSecretList(instance.getSecretList()); 
            this.withSecurityContextConstraints(instance.getSecurityContextConstraints()); 
            this.withSecurityContextConstraintsList(instance.getSecurityContextConstraintsList()); 
            this.withServiceAccount(instance.getServiceAccount()); 
            this.withServiceAccountList(instance.getServiceAccountList()); 
            this.withServiceList(instance.getServiceList()); 
            this.withStatefulSet(instance.getStatefulSet()); 
            this.withStatefulSetList(instance.getStatefulSetList()); 
            this.withStatus(instance.getStatus()); 
            this.withStorageClass(instance.getStorageClass()); 
            this.withStorageClassList(instance.getStorageClassList()); 
            this.withSubjectAccessReview(instance.getSubjectAccessReview()); 
            this.withSubjectAccessReviewResponse(instance.getSubjectAccessReviewResponse()); 
            this.withTagEvent(instance.getTagEvent()); 
            this.withTemplate(instance.getTemplate()); 
            this.withTemplateList(instance.getTemplateList()); 
            this.withThirdPartyResource(instance.getThirdPartyResource()); 
            this.withThirdPartyResourceList(instance.getThirdPartyResourceList()); 
            this.withTokenReview(instance.getTokenReview()); 
            this.withToleration(instance.getToleration()); 
            this.withUser(instance.getUser()); 
            this.withUserList(instance.getUserList()); 
            this.withWatchEvent(instance.getWatchEvent()); 
    }

    
/**
 * This method has been deprecated, please use method buildBaseKubernetesList instead.
 */
@Deprecated public BaseKubernetesList getBaseKubernetesList(){
            return this.baseKubernetesList!=null?this.baseKubernetesList.build():null;
    }

    public BaseKubernetesList buildBaseKubernetesList(){
            return this.baseKubernetesList!=null?this.baseKubernetesList.build():null;
    }

    public A withBaseKubernetesList(BaseKubernetesList baseKubernetesList){
            _visitables.remove(this.baseKubernetesList);
            if (baseKubernetesList!=null){ this.baseKubernetesList= new BaseKubernetesListBuilder(baseKubernetesList); _visitables.add(this.baseKubernetesList);} return (A) this;
    }

    public Boolean hasBaseKubernetesList(){
            return this.baseKubernetesList!=null;
    }

    public KubeSchemaFluent.BaseKubernetesListNested withNewBaseKubernetesList(){
            return new BaseKubernetesListNestedImpl();
    }

    public KubeSchemaFluent.BaseKubernetesListNested withNewBaseKubernetesListLike(BaseKubernetesList item){
            return new BaseKubernetesListNestedImpl(item);
    }

    public KubeSchemaFluent.BaseKubernetesListNested editBaseKubernetesList(){
            return withNewBaseKubernetesListLike(getBaseKubernetesList());
    }

    public KubeSchemaFluent.BaseKubernetesListNested editOrNewBaseKubernetesList(){
            return withNewBaseKubernetesListLike(getBaseKubernetesList() != null ? getBaseKubernetesList(): new BaseKubernetesListBuilder().build());
    }

    public KubeSchemaFluent.BaseKubernetesListNested editOrNewBaseKubernetesListLike(BaseKubernetesList item){
            return withNewBaseKubernetesListLike(getBaseKubernetesList() != null ? getBaseKubernetesList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildBinding instead.
 */
@Deprecated public Binding getBinding(){
            return this.binding!=null?this.binding.build():null;
    }

    public Binding buildBinding(){
            return this.binding!=null?this.binding.build():null;
    }

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

    public Boolean hasBinding(){
            return this.binding!=null;
    }

    public KubeSchemaFluent.BindingNested withNewBinding(){
            return new BindingNestedImpl();
    }

    public KubeSchemaFluent.BindingNested withNewBindingLike(Binding item){
            return new BindingNestedImpl(item);
    }

    public KubeSchemaFluent.BindingNested editBinding(){
            return withNewBindingLike(getBinding());
    }

    public KubeSchemaFluent.BindingNested editOrNewBinding(){
            return withNewBindingLike(getBinding() != null ? getBinding(): new BindingBuilder().build());
    }

    public KubeSchemaFluent.BindingNested editOrNewBindingLike(Binding item){
            return withNewBindingLike(getBinding() != null ? getBinding(): item);
    }

    
/**
 * This method has been deprecated, please use method buildBuildConfigList instead.
 */
@Deprecated public BuildConfigList getBuildConfigList(){
            return this.buildConfigList!=null?this.buildConfigList.build():null;
    }

    public BuildConfigList buildBuildConfigList(){
            return this.buildConfigList!=null?this.buildConfigList.build():null;
    }

    public A withBuildConfigList(BuildConfigList buildConfigList){
            _visitables.remove(this.buildConfigList);
            if (buildConfigList!=null){ this.buildConfigList= new BuildConfigListBuilder(buildConfigList); _visitables.add(this.buildConfigList);} return (A) this;
    }

    public Boolean hasBuildConfigList(){
            return this.buildConfigList!=null;
    }

    public KubeSchemaFluent.BuildConfigListNested withNewBuildConfigList(){
            return new BuildConfigListNestedImpl();
    }

    public KubeSchemaFluent.BuildConfigListNested withNewBuildConfigListLike(BuildConfigList item){
            return new BuildConfigListNestedImpl(item);
    }

    public KubeSchemaFluent.BuildConfigListNested editBuildConfigList(){
            return withNewBuildConfigListLike(getBuildConfigList());
    }

    public KubeSchemaFluent.BuildConfigListNested editOrNewBuildConfigList(){
            return withNewBuildConfigListLike(getBuildConfigList() != null ? getBuildConfigList(): new BuildConfigListBuilder().build());
    }

    public KubeSchemaFluent.BuildConfigListNested editOrNewBuildConfigListLike(BuildConfigList item){
            return withNewBuildConfigListLike(getBuildConfigList() != null ? getBuildConfigList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildBuildList instead.
 */
@Deprecated public BuildList getBuildList(){
            return this.buildList!=null?this.buildList.build():null;
    }

    public BuildList buildBuildList(){
            return this.buildList!=null?this.buildList.build():null;
    }

    public A withBuildList(BuildList buildList){
            _visitables.remove(this.buildList);
            if (buildList!=null){ this.buildList= new BuildListBuilder(buildList); _visitables.add(this.buildList);} return (A) this;
    }

    public Boolean hasBuildList(){
            return this.buildList!=null;
    }

    public KubeSchemaFluent.BuildListNested withNewBuildList(){
            return new BuildListNestedImpl();
    }

    public KubeSchemaFluent.BuildListNested withNewBuildListLike(BuildList item){
            return new BuildListNestedImpl(item);
    }

    public KubeSchemaFluent.BuildListNested editBuildList(){
            return withNewBuildListLike(getBuildList());
    }

    public KubeSchemaFluent.BuildListNested editOrNewBuildList(){
            return withNewBuildListLike(getBuildList() != null ? getBuildList(): new BuildListBuilder().build());
    }

    public KubeSchemaFluent.BuildListNested editOrNewBuildListLike(BuildList item){
            return withNewBuildListLike(getBuildList() != null ? getBuildList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildBuildRequest instead.
 */
@Deprecated public BuildRequest getBuildRequest(){
            return this.buildRequest!=null?this.buildRequest.build():null;
    }

    public BuildRequest buildBuildRequest(){
            return this.buildRequest!=null?this.buildRequest.build():null;
    }

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

    public Boolean hasBuildRequest(){
            return this.buildRequest!=null;
    }

    public KubeSchemaFluent.BuildRequestNested withNewBuildRequest(){
            return new BuildRequestNestedImpl();
    }

    public KubeSchemaFluent.BuildRequestNested withNewBuildRequestLike(BuildRequest item){
            return new BuildRequestNestedImpl(item);
    }

    public KubeSchemaFluent.BuildRequestNested editBuildRequest(){
            return withNewBuildRequestLike(getBuildRequest());
    }

    public KubeSchemaFluent.BuildRequestNested editOrNewBuildRequest(){
            return withNewBuildRequestLike(getBuildRequest() != null ? getBuildRequest(): new BuildRequestBuilder().build());
    }

    public KubeSchemaFluent.BuildRequestNested editOrNewBuildRequestLike(BuildRequest item){
            return withNewBuildRequestLike(getBuildRequest() != null ? getBuildRequest(): item);
    }

    
/**
 * This method has been deprecated, please use method buildClusterPolicy instead.
 */
@Deprecated public ClusterPolicy getClusterPolicy(){
            return this.clusterPolicy!=null?this.clusterPolicy.build():null;
    }

    public ClusterPolicy buildClusterPolicy(){
            return this.clusterPolicy!=null?this.clusterPolicy.build():null;
    }

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

    public Boolean hasClusterPolicy(){
            return this.clusterPolicy!=null;
    }

    public KubeSchemaFluent.ClusterPolicyNested withNewClusterPolicy(){
            return new ClusterPolicyNestedImpl();
    }

    public KubeSchemaFluent.ClusterPolicyNested withNewClusterPolicyLike(ClusterPolicy item){
            return new ClusterPolicyNestedImpl(item);
    }

    public KubeSchemaFluent.ClusterPolicyNested editClusterPolicy(){
            return withNewClusterPolicyLike(getClusterPolicy());
    }

    public KubeSchemaFluent.ClusterPolicyNested editOrNewClusterPolicy(){
            return withNewClusterPolicyLike(getClusterPolicy() != null ? getClusterPolicy(): new ClusterPolicyBuilder().build());
    }

    public KubeSchemaFluent.ClusterPolicyNested editOrNewClusterPolicyLike(ClusterPolicy item){
            return withNewClusterPolicyLike(getClusterPolicy() != null ? getClusterPolicy(): item);
    }

    
/**
 * This method has been deprecated, please use method buildClusterPolicyBinding instead.
 */
@Deprecated public ClusterPolicyBinding getClusterPolicyBinding(){
            return this.clusterPolicyBinding!=null?this.clusterPolicyBinding.build():null;
    }

    public ClusterPolicyBinding buildClusterPolicyBinding(){
            return this.clusterPolicyBinding!=null?this.clusterPolicyBinding.build():null;
    }

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

    public Boolean hasClusterPolicyBinding(){
            return this.clusterPolicyBinding!=null;
    }

    public KubeSchemaFluent.ClusterPolicyBindingNested withNewClusterPolicyBinding(){
            return new ClusterPolicyBindingNestedImpl();
    }

    public KubeSchemaFluent.ClusterPolicyBindingNested withNewClusterPolicyBindingLike(ClusterPolicyBinding item){
            return new ClusterPolicyBindingNestedImpl(item);
    }

    public KubeSchemaFluent.ClusterPolicyBindingNested editClusterPolicyBinding(){
            return withNewClusterPolicyBindingLike(getClusterPolicyBinding());
    }

    public KubeSchemaFluent.ClusterPolicyBindingNested editOrNewClusterPolicyBinding(){
            return withNewClusterPolicyBindingLike(getClusterPolicyBinding() != null ? getClusterPolicyBinding(): new ClusterPolicyBindingBuilder().build());
    }

    public KubeSchemaFluent.ClusterPolicyBindingNested editOrNewClusterPolicyBindingLike(ClusterPolicyBinding item){
            return withNewClusterPolicyBindingLike(getClusterPolicyBinding() != null ? getClusterPolicyBinding(): item);
    }

    
/**
 * This method has been deprecated, please use method buildClusterPolicyBindingList instead.
 */
@Deprecated public ClusterPolicyBindingList getClusterPolicyBindingList(){
            return this.clusterPolicyBindingList!=null?this.clusterPolicyBindingList.build():null;
    }

    public ClusterPolicyBindingList buildClusterPolicyBindingList(){
            return this.clusterPolicyBindingList!=null?this.clusterPolicyBindingList.build():null;
    }

    public A withClusterPolicyBindingList(ClusterPolicyBindingList clusterPolicyBindingList){
            _visitables.remove(this.clusterPolicyBindingList);
            if (clusterPolicyBindingList!=null){ this.clusterPolicyBindingList= new ClusterPolicyBindingListBuilder(clusterPolicyBindingList); _visitables.add(this.clusterPolicyBindingList);} return (A) this;
    }

    public Boolean hasClusterPolicyBindingList(){
            return this.clusterPolicyBindingList!=null;
    }

    public KubeSchemaFluent.ClusterPolicyBindingListNested withNewClusterPolicyBindingList(){
            return new ClusterPolicyBindingListNestedImpl();
    }

    public KubeSchemaFluent.ClusterPolicyBindingListNested withNewClusterPolicyBindingListLike(ClusterPolicyBindingList item){
            return new ClusterPolicyBindingListNestedImpl(item);
    }

    public KubeSchemaFluent.ClusterPolicyBindingListNested editClusterPolicyBindingList(){
            return withNewClusterPolicyBindingListLike(getClusterPolicyBindingList());
    }

    public KubeSchemaFluent.ClusterPolicyBindingListNested editOrNewClusterPolicyBindingList(){
            return withNewClusterPolicyBindingListLike(getClusterPolicyBindingList() != null ? getClusterPolicyBindingList(): new ClusterPolicyBindingListBuilder().build());
    }

    public KubeSchemaFluent.ClusterPolicyBindingListNested editOrNewClusterPolicyBindingListLike(ClusterPolicyBindingList item){
            return withNewClusterPolicyBindingListLike(getClusterPolicyBindingList() != null ? getClusterPolicyBindingList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildClusterPolicyList instead.
 */
@Deprecated public ClusterPolicyList getClusterPolicyList(){
            return this.clusterPolicyList!=null?this.clusterPolicyList.build():null;
    }

    public ClusterPolicyList buildClusterPolicyList(){
            return this.clusterPolicyList!=null?this.clusterPolicyList.build():null;
    }

    public A withClusterPolicyList(ClusterPolicyList clusterPolicyList){
            _visitables.remove(this.clusterPolicyList);
            if (clusterPolicyList!=null){ this.clusterPolicyList= new ClusterPolicyListBuilder(clusterPolicyList); _visitables.add(this.clusterPolicyList);} return (A) this;
    }

    public Boolean hasClusterPolicyList(){
            return this.clusterPolicyList!=null;
    }

    public KubeSchemaFluent.ClusterPolicyListNested withNewClusterPolicyList(){
            return new ClusterPolicyListNestedImpl();
    }

    public KubeSchemaFluent.ClusterPolicyListNested withNewClusterPolicyListLike(ClusterPolicyList item){
            return new ClusterPolicyListNestedImpl(item);
    }

    public KubeSchemaFluent.ClusterPolicyListNested editClusterPolicyList(){
            return withNewClusterPolicyListLike(getClusterPolicyList());
    }

    public KubeSchemaFluent.ClusterPolicyListNested editOrNewClusterPolicyList(){
            return withNewClusterPolicyListLike(getClusterPolicyList() != null ? getClusterPolicyList(): new ClusterPolicyListBuilder().build());
    }

    public KubeSchemaFluent.ClusterPolicyListNested editOrNewClusterPolicyListLike(ClusterPolicyList item){
            return withNewClusterPolicyListLike(getClusterPolicyList() != null ? getClusterPolicyList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildClusterRoleBinding instead.
 */
@Deprecated public ClusterRoleBinding getClusterRoleBinding(){
            return this.clusterRoleBinding!=null?this.clusterRoleBinding.build():null;
    }

    public ClusterRoleBinding buildClusterRoleBinding(){
            return this.clusterRoleBinding!=null?this.clusterRoleBinding.build():null;
    }

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

    public Boolean hasClusterRoleBinding(){
            return this.clusterRoleBinding!=null;
    }

    public KubeSchemaFluent.ClusterRoleBindingNested withNewClusterRoleBinding(){
            return new ClusterRoleBindingNestedImpl();
    }

    public KubeSchemaFluent.ClusterRoleBindingNested withNewClusterRoleBindingLike(ClusterRoleBinding item){
            return new ClusterRoleBindingNestedImpl(item);
    }

    public KubeSchemaFluent.ClusterRoleBindingNested editClusterRoleBinding(){
            return withNewClusterRoleBindingLike(getClusterRoleBinding());
    }

    public KubeSchemaFluent.ClusterRoleBindingNested editOrNewClusterRoleBinding(){
            return withNewClusterRoleBindingLike(getClusterRoleBinding() != null ? getClusterRoleBinding(): new ClusterRoleBindingBuilder().build());
    }

    public KubeSchemaFluent.ClusterRoleBindingNested editOrNewClusterRoleBindingLike(ClusterRoleBinding item){
            return withNewClusterRoleBindingLike(getClusterRoleBinding() != null ? getClusterRoleBinding(): item);
    }

    
/**
 * This method has been deprecated, please use method buildClusterRoleBindingList instead.
 */
@Deprecated public ClusterRoleBindingList getClusterRoleBindingList(){
            return this.clusterRoleBindingList!=null?this.clusterRoleBindingList.build():null;
    }

    public ClusterRoleBindingList buildClusterRoleBindingList(){
            return this.clusterRoleBindingList!=null?this.clusterRoleBindingList.build():null;
    }

    public A withClusterRoleBindingList(ClusterRoleBindingList clusterRoleBindingList){
            _visitables.remove(this.clusterRoleBindingList);
            if (clusterRoleBindingList!=null){ this.clusterRoleBindingList= new ClusterRoleBindingListBuilder(clusterRoleBindingList); _visitables.add(this.clusterRoleBindingList);} return (A) this;
    }

    public Boolean hasClusterRoleBindingList(){
            return this.clusterRoleBindingList!=null;
    }

    public KubeSchemaFluent.ClusterRoleBindingListNested withNewClusterRoleBindingList(){
            return new ClusterRoleBindingListNestedImpl();
    }

    public KubeSchemaFluent.ClusterRoleBindingListNested withNewClusterRoleBindingListLike(ClusterRoleBindingList item){
            return new ClusterRoleBindingListNestedImpl(item);
    }

    public KubeSchemaFluent.ClusterRoleBindingListNested editClusterRoleBindingList(){
            return withNewClusterRoleBindingListLike(getClusterRoleBindingList());
    }

    public KubeSchemaFluent.ClusterRoleBindingListNested editOrNewClusterRoleBindingList(){
            return withNewClusterRoleBindingListLike(getClusterRoleBindingList() != null ? getClusterRoleBindingList(): new ClusterRoleBindingListBuilder().build());
    }

    public KubeSchemaFluent.ClusterRoleBindingListNested editOrNewClusterRoleBindingListLike(ClusterRoleBindingList item){
            return withNewClusterRoleBindingListLike(getClusterRoleBindingList() != null ? getClusterRoleBindingList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildComponentStatusList instead.
 */
@Deprecated public ComponentStatusList getComponentStatusList(){
            return this.componentStatusList!=null?this.componentStatusList.build():null;
    }

    public ComponentStatusList buildComponentStatusList(){
            return this.componentStatusList!=null?this.componentStatusList.build():null;
    }

    public A withComponentStatusList(ComponentStatusList componentStatusList){
            _visitables.remove(this.componentStatusList);
            if (componentStatusList!=null){ this.componentStatusList= new ComponentStatusListBuilder(componentStatusList); _visitables.add(this.componentStatusList);} return (A) this;
    }

    public Boolean hasComponentStatusList(){
            return this.componentStatusList!=null;
    }

    public KubeSchemaFluent.ComponentStatusListNested withNewComponentStatusList(){
            return new ComponentStatusListNestedImpl();
    }

    public KubeSchemaFluent.ComponentStatusListNested withNewComponentStatusListLike(ComponentStatusList item){
            return new ComponentStatusListNestedImpl(item);
    }

    public KubeSchemaFluent.ComponentStatusListNested editComponentStatusList(){
            return withNewComponentStatusListLike(getComponentStatusList());
    }

    public KubeSchemaFluent.ComponentStatusListNested editOrNewComponentStatusList(){
            return withNewComponentStatusListLike(getComponentStatusList() != null ? getComponentStatusList(): new ComponentStatusListBuilder().build());
    }

    public KubeSchemaFluent.ComponentStatusListNested editOrNewComponentStatusListLike(ComponentStatusList item){
            return withNewComponentStatusListLike(getComponentStatusList() != null ? getComponentStatusList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildConfig instead.
 */
@Deprecated public Config getConfig(){
            return this.config!=null?this.config.build():null;
    }

    public Config buildConfig(){
            return this.config!=null?this.config.build():null;
    }

    public A withConfig(Config config){
            _visitables.remove(this.config);
            if (config!=null){ this.config= new ConfigBuilder(config); _visitables.add(this.config);} return (A) this;
    }

    public Boolean hasConfig(){
            return this.config!=null;
    }

    public KubeSchemaFluent.ConfigNested withNewConfig(){
            return new ConfigNestedImpl();
    }

    public KubeSchemaFluent.ConfigNested withNewConfigLike(Config item){
            return new ConfigNestedImpl(item);
    }

    public KubeSchemaFluent.ConfigNested editConfig(){
            return withNewConfigLike(getConfig());
    }

    public KubeSchemaFluent.ConfigNested editOrNewConfig(){
            return withNewConfigLike(getConfig() != null ? getConfig(): new ConfigBuilder().build());
    }

    public KubeSchemaFluent.ConfigNested editOrNewConfigLike(Config item){
            return withNewConfigLike(getConfig() != null ? getConfig(): item);
    }

    
/**
 * This method has been deprecated, please use method buildConfigMap instead.
 */
@Deprecated public ConfigMap getConfigMap(){
            return this.configMap!=null?this.configMap.build():null;
    }

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

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

    public Boolean hasConfigMap(){
            return this.configMap!=null;
    }

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

    public KubeSchemaFluent.ConfigMapNested withNewConfigMapLike(ConfigMap item){
            return new ConfigMapNestedImpl(item);
    }

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

    public KubeSchemaFluent.ConfigMapNested editOrNewConfigMap(){
            return withNewConfigMapLike(getConfigMap() != null ? getConfigMap(): new ConfigMapBuilder().build());
    }

    public KubeSchemaFluent.ConfigMapNested editOrNewConfigMapLike(ConfigMap item){
            return withNewConfigMapLike(getConfigMap() != null ? getConfigMap(): item);
    }

    
/**
 * This method has been deprecated, please use method buildConfigMapList instead.
 */
@Deprecated public ConfigMapList getConfigMapList(){
            return this.configMapList!=null?this.configMapList.build():null;
    }

    public ConfigMapList buildConfigMapList(){
            return this.configMapList!=null?this.configMapList.build():null;
    }

    public A withConfigMapList(ConfigMapList configMapList){
            _visitables.remove(this.configMapList);
            if (configMapList!=null){ this.configMapList= new ConfigMapListBuilder(configMapList); _visitables.add(this.configMapList);} return (A) this;
    }

    public Boolean hasConfigMapList(){
            return this.configMapList!=null;
    }

    public KubeSchemaFluent.ConfigMapListNested withNewConfigMapList(){
            return new ConfigMapListNestedImpl();
    }

    public KubeSchemaFluent.ConfigMapListNested withNewConfigMapListLike(ConfigMapList item){
            return new ConfigMapListNestedImpl(item);
    }

    public KubeSchemaFluent.ConfigMapListNested editConfigMapList(){
            return withNewConfigMapListLike(getConfigMapList());
    }

    public KubeSchemaFluent.ConfigMapListNested editOrNewConfigMapList(){
            return withNewConfigMapListLike(getConfigMapList() != null ? getConfigMapList(): new ConfigMapListBuilder().build());
    }

    public KubeSchemaFluent.ConfigMapListNested editOrNewConfigMapListLike(ConfigMapList item){
            return withNewConfigMapListLike(getConfigMapList() != null ? getConfigMapList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildContainerStatus instead.
 */
@Deprecated public ContainerStatus getContainerStatus(){
            return this.containerStatus!=null?this.containerStatus.build():null;
    }

    public ContainerStatus buildContainerStatus(){
            return this.containerStatus!=null?this.containerStatus.build():null;
    }

    public A withContainerStatus(ContainerStatus containerStatus){
            _visitables.remove(this.containerStatus);
            if (containerStatus!=null){ this.containerStatus= new ContainerStatusBuilder(containerStatus); _visitables.add(this.containerStatus);} return (A) this;
    }

    public Boolean hasContainerStatus(){
            return this.containerStatus!=null;
    }

    public KubeSchemaFluent.ContainerStatusNested withNewContainerStatus(){
            return new ContainerStatusNestedImpl();
    }

    public KubeSchemaFluent.ContainerStatusNested withNewContainerStatusLike(ContainerStatus item){
            return new ContainerStatusNestedImpl(item);
    }

    public KubeSchemaFluent.ContainerStatusNested editContainerStatus(){
            return withNewContainerStatusLike(getContainerStatus());
    }

    public KubeSchemaFluent.ContainerStatusNested editOrNewContainerStatus(){
            return withNewContainerStatusLike(getContainerStatus() != null ? getContainerStatus(): new ContainerStatusBuilder().build());
    }

    public KubeSchemaFluent.ContainerStatusNested editOrNewContainerStatusLike(ContainerStatus item){
            return withNewContainerStatusLike(getContainerStatus() != null ? getContainerStatus(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCronJob instead.
 */
@Deprecated public CronJob getCronJob(){
            return this.cronJob!=null?this.cronJob.build():null;
    }

    public CronJob buildCronJob(){
            return this.cronJob!=null?this.cronJob.build():null;
    }

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

    public Boolean hasCronJob(){
            return this.cronJob!=null;
    }

    public KubeSchemaFluent.CronJobNested withNewCronJob(){
            return new CronJobNestedImpl();
    }

    public KubeSchemaFluent.CronJobNested withNewCronJobLike(CronJob item){
            return new CronJobNestedImpl(item);
    }

    public KubeSchemaFluent.CronJobNested editCronJob(){
            return withNewCronJobLike(getCronJob());
    }

    public KubeSchemaFluent.CronJobNested editOrNewCronJob(){
            return withNewCronJobLike(getCronJob() != null ? getCronJob(): new CronJobBuilder().build());
    }

    public KubeSchemaFluent.CronJobNested editOrNewCronJobLike(CronJob item){
            return withNewCronJobLike(getCronJob() != null ? getCronJob(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCronJobList instead.
 */
@Deprecated public CronJobList getCronJobList(){
            return this.cronJobList!=null?this.cronJobList.build():null;
    }

    public CronJobList buildCronJobList(){
            return this.cronJobList!=null?this.cronJobList.build():null;
    }

    public A withCronJobList(CronJobList cronJobList){
            _visitables.remove(this.cronJobList);
            if (cronJobList!=null){ this.cronJobList= new CronJobListBuilder(cronJobList); _visitables.add(this.cronJobList);} return (A) this;
    }

    public Boolean hasCronJobList(){
            return this.cronJobList!=null;
    }

    public KubeSchemaFluent.CronJobListNested withNewCronJobList(){
            return new CronJobListNestedImpl();
    }

    public KubeSchemaFluent.CronJobListNested withNewCronJobListLike(CronJobList item){
            return new CronJobListNestedImpl(item);
    }

    public KubeSchemaFluent.CronJobListNested editCronJobList(){
            return withNewCronJobListLike(getCronJobList());
    }

    public KubeSchemaFluent.CronJobListNested editOrNewCronJobList(){
            return withNewCronJobListLike(getCronJobList() != null ? getCronJobList(): new CronJobListBuilder().build());
    }

    public KubeSchemaFluent.CronJobListNested editOrNewCronJobListLike(CronJobList item){
            return withNewCronJobListLike(getCronJobList() != null ? getCronJobList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCustomResourceDefinition instead.
 */
@Deprecated public CustomResourceDefinition getCustomResourceDefinition(){
            return this.customResourceDefinition!=null?this.customResourceDefinition.build():null;
    }

    public CustomResourceDefinition buildCustomResourceDefinition(){
            return this.customResourceDefinition!=null?this.customResourceDefinition.build():null;
    }

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

    public Boolean hasCustomResourceDefinition(){
            return this.customResourceDefinition!=null;
    }

    public KubeSchemaFluent.CustomResourceDefinitionNested withNewCustomResourceDefinition(){
            return new CustomResourceDefinitionNestedImpl();
    }

    public KubeSchemaFluent.CustomResourceDefinitionNested withNewCustomResourceDefinitionLike(CustomResourceDefinition item){
            return new CustomResourceDefinitionNestedImpl(item);
    }

    public KubeSchemaFluent.CustomResourceDefinitionNested editCustomResourceDefinition(){
            return withNewCustomResourceDefinitionLike(getCustomResourceDefinition());
    }

    public KubeSchemaFluent.CustomResourceDefinitionNested editOrNewCustomResourceDefinition(){
            return withNewCustomResourceDefinitionLike(getCustomResourceDefinition() != null ? getCustomResourceDefinition(): new CustomResourceDefinitionBuilder().build());
    }

    public KubeSchemaFluent.CustomResourceDefinitionNested editOrNewCustomResourceDefinitionLike(CustomResourceDefinition item){
            return withNewCustomResourceDefinitionLike(getCustomResourceDefinition() != null ? getCustomResourceDefinition(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCustomResourceDefinitionCondition instead.
 */
@Deprecated public CustomResourceDefinitionCondition getCustomResourceDefinitionCondition(){
            return this.customResourceDefinitionCondition!=null?this.customResourceDefinitionCondition.build():null;
    }

    public CustomResourceDefinitionCondition buildCustomResourceDefinitionCondition(){
            return this.customResourceDefinitionCondition!=null?this.customResourceDefinitionCondition.build():null;
    }

    public A withCustomResourceDefinitionCondition(CustomResourceDefinitionCondition customResourceDefinitionCondition){
            _visitables.remove(this.customResourceDefinitionCondition);
            if (customResourceDefinitionCondition!=null){ this.customResourceDefinitionCondition= new CustomResourceDefinitionConditionBuilder(customResourceDefinitionCondition); _visitables.add(this.customResourceDefinitionCondition);} return (A) this;
    }

    public Boolean hasCustomResourceDefinitionCondition(){
            return this.customResourceDefinitionCondition!=null;
    }

    public KubeSchemaFluent.CustomResourceDefinitionConditionNested withNewCustomResourceDefinitionCondition(){
            return new CustomResourceDefinitionConditionNestedImpl();
    }

    public KubeSchemaFluent.CustomResourceDefinitionConditionNested withNewCustomResourceDefinitionConditionLike(CustomResourceDefinitionCondition item){
            return new CustomResourceDefinitionConditionNestedImpl(item);
    }

    public KubeSchemaFluent.CustomResourceDefinitionConditionNested editCustomResourceDefinitionCondition(){
            return withNewCustomResourceDefinitionConditionLike(getCustomResourceDefinitionCondition());
    }

    public KubeSchemaFluent.CustomResourceDefinitionConditionNested editOrNewCustomResourceDefinitionCondition(){
            return withNewCustomResourceDefinitionConditionLike(getCustomResourceDefinitionCondition() != null ? getCustomResourceDefinitionCondition(): new CustomResourceDefinitionConditionBuilder().build());
    }

    public KubeSchemaFluent.CustomResourceDefinitionConditionNested editOrNewCustomResourceDefinitionConditionLike(CustomResourceDefinitionCondition item){
            return withNewCustomResourceDefinitionConditionLike(getCustomResourceDefinitionCondition() != null ? getCustomResourceDefinitionCondition(): item);
    }

    public A withNewCustomResourceDefinitionCondition(String lastTransitionTime,String message,String reason,String status,String type){
            return (A)withCustomResourceDefinitionCondition(new CustomResourceDefinitionCondition(lastTransitionTime, message, reason, status, type));
    }

    
/**
 * This method has been deprecated, please use method buildCustomResourceDefinitionList instead.
 */
@Deprecated public CustomResourceDefinitionList getCustomResourceDefinitionList(){
            return this.customResourceDefinitionList!=null?this.customResourceDefinitionList.build():null;
    }

    public CustomResourceDefinitionList buildCustomResourceDefinitionList(){
            return this.customResourceDefinitionList!=null?this.customResourceDefinitionList.build():null;
    }

    public A withCustomResourceDefinitionList(CustomResourceDefinitionList customResourceDefinitionList){
            _visitables.remove(this.customResourceDefinitionList);
            if (customResourceDefinitionList!=null){ this.customResourceDefinitionList= new CustomResourceDefinitionListBuilder(customResourceDefinitionList); _visitables.add(this.customResourceDefinitionList);} return (A) this;
    }

    public Boolean hasCustomResourceDefinitionList(){
            return this.customResourceDefinitionList!=null;
    }

    public KubeSchemaFluent.CustomResourceDefinitionListNested withNewCustomResourceDefinitionList(){
            return new CustomResourceDefinitionListNestedImpl();
    }

    public KubeSchemaFluent.CustomResourceDefinitionListNested withNewCustomResourceDefinitionListLike(CustomResourceDefinitionList item){
            return new CustomResourceDefinitionListNestedImpl(item);
    }

    public KubeSchemaFluent.CustomResourceDefinitionListNested editCustomResourceDefinitionList(){
            return withNewCustomResourceDefinitionListLike(getCustomResourceDefinitionList());
    }

    public KubeSchemaFluent.CustomResourceDefinitionListNested editOrNewCustomResourceDefinitionList(){
            return withNewCustomResourceDefinitionListLike(getCustomResourceDefinitionList() != null ? getCustomResourceDefinitionList(): new CustomResourceDefinitionListBuilder().build());
    }

    public KubeSchemaFluent.CustomResourceDefinitionListNested editOrNewCustomResourceDefinitionListLike(CustomResourceDefinitionList item){
            return withNewCustomResourceDefinitionListLike(getCustomResourceDefinitionList() != null ? getCustomResourceDefinitionList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCustomResourceDefinitionNames instead.
 */
@Deprecated public CustomResourceDefinitionNames getCustomResourceDefinitionNames(){
            return this.customResourceDefinitionNames!=null?this.customResourceDefinitionNames.build():null;
    }

    public CustomResourceDefinitionNames buildCustomResourceDefinitionNames(){
            return this.customResourceDefinitionNames!=null?this.customResourceDefinitionNames.build():null;
    }

    public A withCustomResourceDefinitionNames(CustomResourceDefinitionNames customResourceDefinitionNames){
            _visitables.remove(this.customResourceDefinitionNames);
            if (customResourceDefinitionNames!=null){ this.customResourceDefinitionNames= new CustomResourceDefinitionNamesBuilder(customResourceDefinitionNames); _visitables.add(this.customResourceDefinitionNames);} return (A) this;
    }

    public Boolean hasCustomResourceDefinitionNames(){
            return this.customResourceDefinitionNames!=null;
    }

    public KubeSchemaFluent.CustomResourceDefinitionNamesNested withNewCustomResourceDefinitionNames(){
            return new CustomResourceDefinitionNamesNestedImpl();
    }

    public KubeSchemaFluent.CustomResourceDefinitionNamesNested withNewCustomResourceDefinitionNamesLike(CustomResourceDefinitionNames item){
            return new CustomResourceDefinitionNamesNestedImpl(item);
    }

    public KubeSchemaFluent.CustomResourceDefinitionNamesNested editCustomResourceDefinitionNames(){
            return withNewCustomResourceDefinitionNamesLike(getCustomResourceDefinitionNames());
    }

    public KubeSchemaFluent.CustomResourceDefinitionNamesNested editOrNewCustomResourceDefinitionNames(){
            return withNewCustomResourceDefinitionNamesLike(getCustomResourceDefinitionNames() != null ? getCustomResourceDefinitionNames(): new CustomResourceDefinitionNamesBuilder().build());
    }

    public KubeSchemaFluent.CustomResourceDefinitionNamesNested editOrNewCustomResourceDefinitionNamesLike(CustomResourceDefinitionNames item){
            return withNewCustomResourceDefinitionNamesLike(getCustomResourceDefinitionNames() != null ? getCustomResourceDefinitionNames(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCustomResourceDefinitionSpec instead.
 */
@Deprecated public CustomResourceDefinitionSpec getCustomResourceDefinitionSpec(){
            return this.customResourceDefinitionSpec!=null?this.customResourceDefinitionSpec.build():null;
    }

    public CustomResourceDefinitionSpec buildCustomResourceDefinitionSpec(){
            return this.customResourceDefinitionSpec!=null?this.customResourceDefinitionSpec.build():null;
    }

    public A withCustomResourceDefinitionSpec(CustomResourceDefinitionSpec customResourceDefinitionSpec){
            _visitables.remove(this.customResourceDefinitionSpec);
            if (customResourceDefinitionSpec!=null){ this.customResourceDefinitionSpec= new CustomResourceDefinitionSpecBuilder(customResourceDefinitionSpec); _visitables.add(this.customResourceDefinitionSpec);} return (A) this;
    }

    public Boolean hasCustomResourceDefinitionSpec(){
            return this.customResourceDefinitionSpec!=null;
    }

    public KubeSchemaFluent.CustomResourceDefinitionSpecNested withNewCustomResourceDefinitionSpec(){
            return new CustomResourceDefinitionSpecNestedImpl();
    }

    public KubeSchemaFluent.CustomResourceDefinitionSpecNested withNewCustomResourceDefinitionSpecLike(CustomResourceDefinitionSpec item){
            return new CustomResourceDefinitionSpecNestedImpl(item);
    }

    public KubeSchemaFluent.CustomResourceDefinitionSpecNested editCustomResourceDefinitionSpec(){
            return withNewCustomResourceDefinitionSpecLike(getCustomResourceDefinitionSpec());
    }

    public KubeSchemaFluent.CustomResourceDefinitionSpecNested editOrNewCustomResourceDefinitionSpec(){
            return withNewCustomResourceDefinitionSpecLike(getCustomResourceDefinitionSpec() != null ? getCustomResourceDefinitionSpec(): new CustomResourceDefinitionSpecBuilder().build());
    }

    public KubeSchemaFluent.CustomResourceDefinitionSpecNested editOrNewCustomResourceDefinitionSpecLike(CustomResourceDefinitionSpec item){
            return withNewCustomResourceDefinitionSpecLike(getCustomResourceDefinitionSpec() != null ? getCustomResourceDefinitionSpec(): item);
    }

    
/**
 * This method has been deprecated, please use method buildCustomResourceDefinitionStatus instead.
 */
@Deprecated public CustomResourceDefinitionStatus getCustomResourceDefinitionStatus(){
            return this.customResourceDefinitionStatus!=null?this.customResourceDefinitionStatus.build():null;
    }

    public CustomResourceDefinitionStatus buildCustomResourceDefinitionStatus(){
            return this.customResourceDefinitionStatus!=null?this.customResourceDefinitionStatus.build():null;
    }

    public A withCustomResourceDefinitionStatus(CustomResourceDefinitionStatus customResourceDefinitionStatus){
            _visitables.remove(this.customResourceDefinitionStatus);
            if (customResourceDefinitionStatus!=null){ this.customResourceDefinitionStatus= new CustomResourceDefinitionStatusBuilder(customResourceDefinitionStatus); _visitables.add(this.customResourceDefinitionStatus);} return (A) this;
    }

    public Boolean hasCustomResourceDefinitionStatus(){
            return this.customResourceDefinitionStatus!=null;
    }

    public KubeSchemaFluent.CustomResourceDefinitionStatusNested withNewCustomResourceDefinitionStatus(){
            return new CustomResourceDefinitionStatusNestedImpl();
    }

    public KubeSchemaFluent.CustomResourceDefinitionStatusNested withNewCustomResourceDefinitionStatusLike(CustomResourceDefinitionStatus item){
            return new CustomResourceDefinitionStatusNestedImpl(item);
    }

    public KubeSchemaFluent.CustomResourceDefinitionStatusNested editCustomResourceDefinitionStatus(){
            return withNewCustomResourceDefinitionStatusLike(getCustomResourceDefinitionStatus());
    }

    public KubeSchemaFluent.CustomResourceDefinitionStatusNested editOrNewCustomResourceDefinitionStatus(){
            return withNewCustomResourceDefinitionStatusLike(getCustomResourceDefinitionStatus() != null ? getCustomResourceDefinitionStatus(): new CustomResourceDefinitionStatusBuilder().build());
    }

    public KubeSchemaFluent.CustomResourceDefinitionStatusNested editOrNewCustomResourceDefinitionStatusLike(CustomResourceDefinitionStatus item){
            return withNewCustomResourceDefinitionStatusLike(getCustomResourceDefinitionStatus() != null ? getCustomResourceDefinitionStatus(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDaemonSet instead.
 */
@Deprecated public DaemonSet getDaemonSet(){
            return this.daemonSet!=null?this.daemonSet.build():null;
    }

    public DaemonSet buildDaemonSet(){
            return this.daemonSet!=null?this.daemonSet.build():null;
    }

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

    public Boolean hasDaemonSet(){
            return this.daemonSet!=null;
    }

    public KubeSchemaFluent.DaemonSetNested withNewDaemonSet(){
            return new DaemonSetNestedImpl();
    }

    public KubeSchemaFluent.DaemonSetNested withNewDaemonSetLike(DaemonSet item){
            return new DaemonSetNestedImpl(item);
    }

    public KubeSchemaFluent.DaemonSetNested editDaemonSet(){
            return withNewDaemonSetLike(getDaemonSet());
    }

    public KubeSchemaFluent.DaemonSetNested editOrNewDaemonSet(){
            return withNewDaemonSetLike(getDaemonSet() != null ? getDaemonSet(): new DaemonSetBuilder().build());
    }

    public KubeSchemaFluent.DaemonSetNested editOrNewDaemonSetLike(DaemonSet item){
            return withNewDaemonSetLike(getDaemonSet() != null ? getDaemonSet(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDaemonSetList instead.
 */
@Deprecated public DaemonSetList getDaemonSetList(){
            return this.daemonSetList!=null?this.daemonSetList.build():null;
    }

    public DaemonSetList buildDaemonSetList(){
            return this.daemonSetList!=null?this.daemonSetList.build():null;
    }

    public A withDaemonSetList(DaemonSetList daemonSetList){
            _visitables.remove(this.daemonSetList);
            if (daemonSetList!=null){ this.daemonSetList= new DaemonSetListBuilder(daemonSetList); _visitables.add(this.daemonSetList);} return (A) this;
    }

    public Boolean hasDaemonSetList(){
            return this.daemonSetList!=null;
    }

    public KubeSchemaFluent.DaemonSetListNested withNewDaemonSetList(){
            return new DaemonSetListNestedImpl();
    }

    public KubeSchemaFluent.DaemonSetListNested withNewDaemonSetListLike(DaemonSetList item){
            return new DaemonSetListNestedImpl(item);
    }

    public KubeSchemaFluent.DaemonSetListNested editDaemonSetList(){
            return withNewDaemonSetListLike(getDaemonSetList());
    }

    public KubeSchemaFluent.DaemonSetListNested editOrNewDaemonSetList(){
            return withNewDaemonSetListLike(getDaemonSetList() != null ? getDaemonSetList(): new DaemonSetListBuilder().build());
    }

    public KubeSchemaFluent.DaemonSetListNested editOrNewDaemonSetListLike(DaemonSetList item){
            return withNewDaemonSetListLike(getDaemonSetList() != null ? getDaemonSetList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDeleteOptions instead.
 */
@Deprecated public DeleteOptions getDeleteOptions(){
            return this.deleteOptions!=null?this.deleteOptions.build():null;
    }

    public DeleteOptions buildDeleteOptions(){
            return this.deleteOptions!=null?this.deleteOptions.build():null;
    }

    public A withDeleteOptions(DeleteOptions deleteOptions){
            _visitables.remove(this.deleteOptions);
            if (deleteOptions!=null){ this.deleteOptions= new DeleteOptionsBuilder(deleteOptions); _visitables.add(this.deleteOptions);} return (A) this;
    }

    public Boolean hasDeleteOptions(){
            return this.deleteOptions!=null;
    }

    public KubeSchemaFluent.DeleteOptionsNested withNewDeleteOptions(){
            return new DeleteOptionsNestedImpl();
    }

    public KubeSchemaFluent.DeleteOptionsNested withNewDeleteOptionsLike(DeleteOptions item){
            return new DeleteOptionsNestedImpl(item);
    }

    public KubeSchemaFluent.DeleteOptionsNested editDeleteOptions(){
            return withNewDeleteOptionsLike(getDeleteOptions());
    }

    public KubeSchemaFluent.DeleteOptionsNested editOrNewDeleteOptions(){
            return withNewDeleteOptionsLike(getDeleteOptions() != null ? getDeleteOptions(): new DeleteOptionsBuilder().build());
    }

    public KubeSchemaFluent.DeleteOptionsNested editOrNewDeleteOptionsLike(DeleteOptions item){
            return withNewDeleteOptionsLike(getDeleteOptions() != null ? getDeleteOptions(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDeployment instead.
 */
@Deprecated public Deployment getDeployment(){
            return this.deployment!=null?this.deployment.build():null;
    }

    public Deployment buildDeployment(){
            return this.deployment!=null?this.deployment.build():null;
    }

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

    public Boolean hasDeployment(){
            return this.deployment!=null;
    }

    public KubeSchemaFluent.DeploymentNested withNewDeployment(){
            return new DeploymentNestedImpl();
    }

    public KubeSchemaFluent.DeploymentNested withNewDeploymentLike(Deployment item){
            return new DeploymentNestedImpl(item);
    }

    public KubeSchemaFluent.DeploymentNested editDeployment(){
            return withNewDeploymentLike(getDeployment());
    }

    public KubeSchemaFluent.DeploymentNested editOrNewDeployment(){
            return withNewDeploymentLike(getDeployment() != null ? getDeployment(): new DeploymentBuilder().build());
    }

    public KubeSchemaFluent.DeploymentNested editOrNewDeploymentLike(Deployment item){
            return withNewDeploymentLike(getDeployment() != null ? getDeployment(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDeploymentConfig instead.
 */
@Deprecated public DeploymentConfig getDeploymentConfig(){
            return this.deploymentConfig!=null?this.deploymentConfig.build():null;
    }

    public DeploymentConfig buildDeploymentConfig(){
            return this.deploymentConfig!=null?this.deploymentConfig.build():null;
    }

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

    public Boolean hasDeploymentConfig(){
            return this.deploymentConfig!=null;
    }

    public KubeSchemaFluent.DeploymentConfigNested withNewDeploymentConfig(){
            return new DeploymentConfigNestedImpl();
    }

    public KubeSchemaFluent.DeploymentConfigNested withNewDeploymentConfigLike(DeploymentConfig item){
            return new DeploymentConfigNestedImpl(item);
    }

    public KubeSchemaFluent.DeploymentConfigNested editDeploymentConfig(){
            return withNewDeploymentConfigLike(getDeploymentConfig());
    }

    public KubeSchemaFluent.DeploymentConfigNested editOrNewDeploymentConfig(){
            return withNewDeploymentConfigLike(getDeploymentConfig() != null ? getDeploymentConfig(): new DeploymentConfigBuilder().build());
    }

    public KubeSchemaFluent.DeploymentConfigNested editOrNewDeploymentConfigLike(DeploymentConfig item){
            return withNewDeploymentConfigLike(getDeploymentConfig() != null ? getDeploymentConfig(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDeploymentConfigList instead.
 */
@Deprecated public DeploymentConfigList getDeploymentConfigList(){
            return this.deploymentConfigList!=null?this.deploymentConfigList.build():null;
    }

    public DeploymentConfigList buildDeploymentConfigList(){
            return this.deploymentConfigList!=null?this.deploymentConfigList.build():null;
    }

    public A withDeploymentConfigList(DeploymentConfigList deploymentConfigList){
            _visitables.remove(this.deploymentConfigList);
            if (deploymentConfigList!=null){ this.deploymentConfigList= new DeploymentConfigListBuilder(deploymentConfigList); _visitables.add(this.deploymentConfigList);} return (A) this;
    }

    public Boolean hasDeploymentConfigList(){
            return this.deploymentConfigList!=null;
    }

    public KubeSchemaFluent.DeploymentConfigListNested withNewDeploymentConfigList(){
            return new DeploymentConfigListNestedImpl();
    }

    public KubeSchemaFluent.DeploymentConfigListNested withNewDeploymentConfigListLike(DeploymentConfigList item){
            return new DeploymentConfigListNestedImpl(item);
    }

    public KubeSchemaFluent.DeploymentConfigListNested editDeploymentConfigList(){
            return withNewDeploymentConfigListLike(getDeploymentConfigList());
    }

    public KubeSchemaFluent.DeploymentConfigListNested editOrNewDeploymentConfigList(){
            return withNewDeploymentConfigListLike(getDeploymentConfigList() != null ? getDeploymentConfigList(): new DeploymentConfigListBuilder().build());
    }

    public KubeSchemaFluent.DeploymentConfigListNested editOrNewDeploymentConfigListLike(DeploymentConfigList item){
            return withNewDeploymentConfigListLike(getDeploymentConfigList() != null ? getDeploymentConfigList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDeploymentList instead.
 */
@Deprecated public DeploymentList getDeploymentList(){
            return this.deploymentList!=null?this.deploymentList.build():null;
    }

    public DeploymentList buildDeploymentList(){
            return this.deploymentList!=null?this.deploymentList.build():null;
    }

    public A withDeploymentList(DeploymentList deploymentList){
            _visitables.remove(this.deploymentList);
            if (deploymentList!=null){ this.deploymentList= new DeploymentListBuilder(deploymentList); _visitables.add(this.deploymentList);} return (A) this;
    }

    public Boolean hasDeploymentList(){
            return this.deploymentList!=null;
    }

    public KubeSchemaFluent.DeploymentListNested withNewDeploymentList(){
            return new DeploymentListNestedImpl();
    }

    public KubeSchemaFluent.DeploymentListNested withNewDeploymentListLike(DeploymentList item){
            return new DeploymentListNestedImpl(item);
    }

    public KubeSchemaFluent.DeploymentListNested editDeploymentList(){
            return withNewDeploymentListLike(getDeploymentList());
    }

    public KubeSchemaFluent.DeploymentListNested editOrNewDeploymentList(){
            return withNewDeploymentListLike(getDeploymentList() != null ? getDeploymentList(): new DeploymentListBuilder().build());
    }

    public KubeSchemaFluent.DeploymentListNested editOrNewDeploymentListLike(DeploymentList item){
            return withNewDeploymentListLike(getDeploymentList() != null ? getDeploymentList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDeploymentRollback instead.
 */
@Deprecated public DeploymentRollback getDeploymentRollback(){
            return this.deploymentRollback!=null?this.deploymentRollback.build():null;
    }

    public DeploymentRollback buildDeploymentRollback(){
            return this.deploymentRollback!=null?this.deploymentRollback.build():null;
    }

    public A withDeploymentRollback(DeploymentRollback deploymentRollback){
            _visitables.remove(this.deploymentRollback);
            if (deploymentRollback!=null){ this.deploymentRollback= new DeploymentRollbackBuilder(deploymentRollback); _visitables.add(this.deploymentRollback);} return (A) this;
    }

    public Boolean hasDeploymentRollback(){
            return this.deploymentRollback!=null;
    }

    public KubeSchemaFluent.DeploymentRollbackNested withNewDeploymentRollback(){
            return new DeploymentRollbackNestedImpl();
    }

    public KubeSchemaFluent.DeploymentRollbackNested withNewDeploymentRollbackLike(DeploymentRollback item){
            return new DeploymentRollbackNestedImpl(item);
    }

    public KubeSchemaFluent.DeploymentRollbackNested editDeploymentRollback(){
            return withNewDeploymentRollbackLike(getDeploymentRollback());
    }

    public KubeSchemaFluent.DeploymentRollbackNested editOrNewDeploymentRollback(){
            return withNewDeploymentRollbackLike(getDeploymentRollback() != null ? getDeploymentRollback(): new DeploymentRollbackBuilder().build());
    }

    public KubeSchemaFluent.DeploymentRollbackNested editOrNewDeploymentRollbackLike(DeploymentRollback item){
            return withNewDeploymentRollbackLike(getDeploymentRollback() != null ? getDeploymentRollback(): item);
    }

    
/**
 * This method has been deprecated, please use method buildEndpoints instead.
 */
@Deprecated public Endpoints getEndpoints(){
            return this.endpoints!=null?this.endpoints.build():null;
    }

    public Endpoints buildEndpoints(){
            return this.endpoints!=null?this.endpoints.build():null;
    }

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

    public Boolean hasEndpoints(){
            return this.endpoints!=null;
    }

    public KubeSchemaFluent.EndpointsNested withNewEndpoints(){
            return new EndpointsNestedImpl();
    }

    public KubeSchemaFluent.EndpointsNested withNewEndpointsLike(Endpoints item){
            return new EndpointsNestedImpl(item);
    }

    public KubeSchemaFluent.EndpointsNested editEndpoints(){
            return withNewEndpointsLike(getEndpoints());
    }

    public KubeSchemaFluent.EndpointsNested editOrNewEndpoints(){
            return withNewEndpointsLike(getEndpoints() != null ? getEndpoints(): new EndpointsBuilder().build());
    }

    public KubeSchemaFluent.EndpointsNested editOrNewEndpointsLike(Endpoints item){
            return withNewEndpointsLike(getEndpoints() != null ? getEndpoints(): item);
    }

    
/**
 * This method has been deprecated, please use method buildEndpointsList instead.
 */
@Deprecated public EndpointsList getEndpointsList(){
            return this.endpointsList!=null?this.endpointsList.build():null;
    }

    public EndpointsList buildEndpointsList(){
            return this.endpointsList!=null?this.endpointsList.build():null;
    }

    public A withEndpointsList(EndpointsList endpointsList){
            _visitables.remove(this.endpointsList);
            if (endpointsList!=null){ this.endpointsList= new EndpointsListBuilder(endpointsList); _visitables.add(this.endpointsList);} return (A) this;
    }

    public Boolean hasEndpointsList(){
            return this.endpointsList!=null;
    }

    public KubeSchemaFluent.EndpointsListNested withNewEndpointsList(){
            return new EndpointsListNestedImpl();
    }

    public KubeSchemaFluent.EndpointsListNested withNewEndpointsListLike(EndpointsList item){
            return new EndpointsListNestedImpl(item);
    }

    public KubeSchemaFluent.EndpointsListNested editEndpointsList(){
            return withNewEndpointsListLike(getEndpointsList());
    }

    public KubeSchemaFluent.EndpointsListNested editOrNewEndpointsList(){
            return withNewEndpointsListLike(getEndpointsList() != null ? getEndpointsList(): new EndpointsListBuilder().build());
    }

    public KubeSchemaFluent.EndpointsListNested editOrNewEndpointsListLike(EndpointsList item){
            return withNewEndpointsListLike(getEndpointsList() != null ? getEndpointsList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildEnvVar instead.
 */
@Deprecated public EnvVar getEnvVar(){
            return this.envVar!=null?this.envVar.build():null;
    }

    public EnvVar buildEnvVar(){
            return this.envVar!=null?this.envVar.build():null;
    }

    public A withEnvVar(EnvVar envVar){
            _visitables.remove(this.envVar);
            if (envVar!=null){ this.envVar= new EnvVarBuilder(envVar); _visitables.add(this.envVar);} return (A) this;
    }

    public Boolean hasEnvVar(){
            return this.envVar!=null;
    }

    public KubeSchemaFluent.EnvVarNested withNewEnvVar(){
            return new EnvVarNestedImpl();
    }

    public KubeSchemaFluent.EnvVarNested withNewEnvVarLike(EnvVar item){
            return new EnvVarNestedImpl(item);
    }

    public KubeSchemaFluent.EnvVarNested editEnvVar(){
            return withNewEnvVarLike(getEnvVar());
    }

    public KubeSchemaFluent.EnvVarNested editOrNewEnvVar(){
            return withNewEnvVarLike(getEnvVar() != null ? getEnvVar(): new EnvVarBuilder().build());
    }

    public KubeSchemaFluent.EnvVarNested editOrNewEnvVarLike(EnvVar item){
            return withNewEnvVarLike(getEnvVar() != null ? getEnvVar(): item);
    }

    
/**
 * This method has been deprecated, please use method buildEventList instead.
 */
@Deprecated public EventList getEventList(){
            return this.eventList!=null?this.eventList.build():null;
    }

    public EventList buildEventList(){
            return this.eventList!=null?this.eventList.build():null;
    }

    public A withEventList(EventList eventList){
            _visitables.remove(this.eventList);
            if (eventList!=null){ this.eventList= new EventListBuilder(eventList); _visitables.add(this.eventList);} return (A) this;
    }

    public Boolean hasEventList(){
            return this.eventList!=null;
    }

    public KubeSchemaFluent.EventListNested withNewEventList(){
            return new EventListNestedImpl();
    }

    public KubeSchemaFluent.EventListNested withNewEventListLike(EventList item){
            return new EventListNestedImpl(item);
    }

    public KubeSchemaFluent.EventListNested editEventList(){
            return withNewEventListLike(getEventList());
    }

    public KubeSchemaFluent.EventListNested editOrNewEventList(){
            return withNewEventListLike(getEventList() != null ? getEventList(): new EventListBuilder().build());
    }

    public KubeSchemaFluent.EventListNested editOrNewEventListLike(EventList item){
            return withNewEventListLike(getEventList() != null ? getEventList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildGroup instead.
 */
@Deprecated public Group getGroup(){
            return this.group!=null?this.group.build():null;
    }

    public Group buildGroup(){
            return this.group!=null?this.group.build():null;
    }

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

    public Boolean hasGroup(){
            return this.group!=null;
    }

    public KubeSchemaFluent.GroupNested withNewGroup(){
            return new GroupNestedImpl();
    }

    public KubeSchemaFluent.GroupNested withNewGroupLike(Group item){
            return new GroupNestedImpl(item);
    }

    public KubeSchemaFluent.GroupNested editGroup(){
            return withNewGroupLike(getGroup());
    }

    public KubeSchemaFluent.GroupNested editOrNewGroup(){
            return withNewGroupLike(getGroup() != null ? getGroup(): new GroupBuilder().build());
    }

    public KubeSchemaFluent.GroupNested editOrNewGroupLike(Group item){
            return withNewGroupLike(getGroup() != null ? getGroup(): item);
    }

    
/**
 * This method has been deprecated, please use method buildGroupList instead.
 */
@Deprecated public GroupList getGroupList(){
            return this.groupList!=null?this.groupList.build():null;
    }

    public GroupList buildGroupList(){
            return this.groupList!=null?this.groupList.build():null;
    }

    public A withGroupList(GroupList groupList){
            _visitables.remove(this.groupList);
            if (groupList!=null){ this.groupList= new GroupListBuilder(groupList); _visitables.add(this.groupList);} return (A) this;
    }

    public Boolean hasGroupList(){
            return this.groupList!=null;
    }

    public KubeSchemaFluent.GroupListNested withNewGroupList(){
            return new GroupListNestedImpl();
    }

    public KubeSchemaFluent.GroupListNested withNewGroupListLike(GroupList item){
            return new GroupListNestedImpl(item);
    }

    public KubeSchemaFluent.GroupListNested editGroupList(){
            return withNewGroupListLike(getGroupList());
    }

    public KubeSchemaFluent.GroupListNested editOrNewGroupList(){
            return withNewGroupListLike(getGroupList() != null ? getGroupList(): new GroupListBuilder().build());
    }

    public KubeSchemaFluent.GroupListNested editOrNewGroupListLike(GroupList item){
            return withNewGroupListLike(getGroupList() != null ? getGroupList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildHorizontalPodAutoscaler instead.
 */
@Deprecated public HorizontalPodAutoscaler getHorizontalPodAutoscaler(){
            return this.horizontalPodAutoscaler!=null?this.horizontalPodAutoscaler.build():null;
    }

    public HorizontalPodAutoscaler buildHorizontalPodAutoscaler(){
            return this.horizontalPodAutoscaler!=null?this.horizontalPodAutoscaler.build():null;
    }

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

    public Boolean hasHorizontalPodAutoscaler(){
            return this.horizontalPodAutoscaler!=null;
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerNested withNewHorizontalPodAutoscaler(){
            return new HorizontalPodAutoscalerNestedImpl();
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerNested withNewHorizontalPodAutoscalerLike(HorizontalPodAutoscaler item){
            return new HorizontalPodAutoscalerNestedImpl(item);
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerNested editHorizontalPodAutoscaler(){
            return withNewHorizontalPodAutoscalerLike(getHorizontalPodAutoscaler());
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerNested editOrNewHorizontalPodAutoscaler(){
            return withNewHorizontalPodAutoscalerLike(getHorizontalPodAutoscaler() != null ? getHorizontalPodAutoscaler(): new HorizontalPodAutoscalerBuilder().build());
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerNested editOrNewHorizontalPodAutoscalerLike(HorizontalPodAutoscaler item){
            return withNewHorizontalPodAutoscalerLike(getHorizontalPodAutoscaler() != null ? getHorizontalPodAutoscaler(): item);
    }

    
/**
 * This method has been deprecated, please use method buildHorizontalPodAutoscalerList instead.
 */
@Deprecated public HorizontalPodAutoscalerList getHorizontalPodAutoscalerList(){
            return this.horizontalPodAutoscalerList!=null?this.horizontalPodAutoscalerList.build():null;
    }

    public HorizontalPodAutoscalerList buildHorizontalPodAutoscalerList(){
            return this.horizontalPodAutoscalerList!=null?this.horizontalPodAutoscalerList.build():null;
    }

    public A withHorizontalPodAutoscalerList(HorizontalPodAutoscalerList horizontalPodAutoscalerList){
            _visitables.remove(this.horizontalPodAutoscalerList);
            if (horizontalPodAutoscalerList!=null){ this.horizontalPodAutoscalerList= new HorizontalPodAutoscalerListBuilder(horizontalPodAutoscalerList); _visitables.add(this.horizontalPodAutoscalerList);} return (A) this;
    }

    public Boolean hasHorizontalPodAutoscalerList(){
            return this.horizontalPodAutoscalerList!=null;
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerListNested withNewHorizontalPodAutoscalerList(){
            return new HorizontalPodAutoscalerListNestedImpl();
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerListNested withNewHorizontalPodAutoscalerListLike(HorizontalPodAutoscalerList item){
            return new HorizontalPodAutoscalerListNestedImpl(item);
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerListNested editHorizontalPodAutoscalerList(){
            return withNewHorizontalPodAutoscalerListLike(getHorizontalPodAutoscalerList());
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerListNested editOrNewHorizontalPodAutoscalerList(){
            return withNewHorizontalPodAutoscalerListLike(getHorizontalPodAutoscalerList() != null ? getHorizontalPodAutoscalerList(): new HorizontalPodAutoscalerListBuilder().build());
    }

    public KubeSchemaFluent.HorizontalPodAutoscalerListNested editOrNewHorizontalPodAutoscalerListLike(HorizontalPodAutoscalerList item){
            return withNewHorizontalPodAutoscalerListLike(getHorizontalPodAutoscalerList() != null ? getHorizontalPodAutoscalerList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildIdentity instead.
 */
@Deprecated public Identity getIdentity(){
            return this.identity!=null?this.identity.build():null;
    }

    public Identity buildIdentity(){
            return this.identity!=null?this.identity.build():null;
    }

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

    public Boolean hasIdentity(){
            return this.identity!=null;
    }

    public KubeSchemaFluent.IdentityNested withNewIdentity(){
            return new IdentityNestedImpl();
    }

    public KubeSchemaFluent.IdentityNested withNewIdentityLike(Identity item){
            return new IdentityNestedImpl(item);
    }

    public KubeSchemaFluent.IdentityNested editIdentity(){
            return withNewIdentityLike(getIdentity());
    }

    public KubeSchemaFluent.IdentityNested editOrNewIdentity(){
            return withNewIdentityLike(getIdentity() != null ? getIdentity(): new IdentityBuilder().build());
    }

    public KubeSchemaFluent.IdentityNested editOrNewIdentityLike(Identity item){
            return withNewIdentityLike(getIdentity() != null ? getIdentity(): item);
    }

    
/**
 * This method has been deprecated, please use method buildIdentityList instead.
 */
@Deprecated public IdentityList getIdentityList(){
            return this.identityList!=null?this.identityList.build():null;
    }

    public IdentityList buildIdentityList(){
            return this.identityList!=null?this.identityList.build():null;
    }

    public A withIdentityList(IdentityList identityList){
            _visitables.remove(this.identityList);
            if (identityList!=null){ this.identityList= new IdentityListBuilder(identityList); _visitables.add(this.identityList);} return (A) this;
    }

    public Boolean hasIdentityList(){
            return this.identityList!=null;
    }

    public KubeSchemaFluent.IdentityListNested withNewIdentityList(){
            return new IdentityListNestedImpl();
    }

    public KubeSchemaFluent.IdentityListNested withNewIdentityListLike(IdentityList item){
            return new IdentityListNestedImpl(item);
    }

    public KubeSchemaFluent.IdentityListNested editIdentityList(){
            return withNewIdentityListLike(getIdentityList());
    }

    public KubeSchemaFluent.IdentityListNested editOrNewIdentityList(){
            return withNewIdentityListLike(getIdentityList() != null ? getIdentityList(): new IdentityListBuilder().build());
    }

    public KubeSchemaFluent.IdentityListNested editOrNewIdentityListLike(IdentityList item){
            return withNewIdentityListLike(getIdentityList() != null ? getIdentityList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildImageList instead.
 */
@Deprecated public ImageList getImageList(){
            return this.imageList!=null?this.imageList.build():null;
    }

    public ImageList buildImageList(){
            return this.imageList!=null?this.imageList.build():null;
    }

    public A withImageList(ImageList imageList){
            _visitables.remove(this.imageList);
            if (imageList!=null){ this.imageList= new ImageListBuilder(imageList); _visitables.add(this.imageList);} return (A) this;
    }

    public Boolean hasImageList(){
            return this.imageList!=null;
    }

    public KubeSchemaFluent.ImageListNested withNewImageList(){
            return new ImageListNestedImpl();
    }

    public KubeSchemaFluent.ImageListNested withNewImageListLike(ImageList item){
            return new ImageListNestedImpl(item);
    }

    public KubeSchemaFluent.ImageListNested editImageList(){
            return withNewImageListLike(getImageList());
    }

    public KubeSchemaFluent.ImageListNested editOrNewImageList(){
            return withNewImageListLike(getImageList() != null ? getImageList(): new ImageListBuilder().build());
    }

    public KubeSchemaFluent.ImageListNested editOrNewImageListLike(ImageList item){
            return withNewImageListLike(getImageList() != null ? getImageList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildImageStreamList instead.
 */
@Deprecated public ImageStreamList getImageStreamList(){
            return this.imageStreamList!=null?this.imageStreamList.build():null;
    }

    public ImageStreamList buildImageStreamList(){
            return this.imageStreamList!=null?this.imageStreamList.build():null;
    }

    public A withImageStreamList(ImageStreamList imageStreamList){
            _visitables.remove(this.imageStreamList);
            if (imageStreamList!=null){ this.imageStreamList= new ImageStreamListBuilder(imageStreamList); _visitables.add(this.imageStreamList);} return (A) this;
    }

    public Boolean hasImageStreamList(){
            return this.imageStreamList!=null;
    }

    public KubeSchemaFluent.ImageStreamListNested withNewImageStreamList(){
            return new ImageStreamListNestedImpl();
    }

    public KubeSchemaFluent.ImageStreamListNested withNewImageStreamListLike(ImageStreamList item){
            return new ImageStreamListNestedImpl(item);
    }

    public KubeSchemaFluent.ImageStreamListNested editImageStreamList(){
            return withNewImageStreamListLike(getImageStreamList());
    }

    public KubeSchemaFluent.ImageStreamListNested editOrNewImageStreamList(){
            return withNewImageStreamListLike(getImageStreamList() != null ? getImageStreamList(): new ImageStreamListBuilder().build());
    }

    public KubeSchemaFluent.ImageStreamListNested editOrNewImageStreamListLike(ImageStreamList item){
            return withNewImageStreamListLike(getImageStreamList() != null ? getImageStreamList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildImageStreamTagList instead.
 */
@Deprecated public ImageStreamTagList getImageStreamTagList(){
            return this.imageStreamTagList!=null?this.imageStreamTagList.build():null;
    }

    public ImageStreamTagList buildImageStreamTagList(){
            return this.imageStreamTagList!=null?this.imageStreamTagList.build():null;
    }

    public A withImageStreamTagList(ImageStreamTagList imageStreamTagList){
            _visitables.remove(this.imageStreamTagList);
            if (imageStreamTagList!=null){ this.imageStreamTagList= new ImageStreamTagListBuilder(imageStreamTagList); _visitables.add(this.imageStreamTagList);} return (A) this;
    }

    public Boolean hasImageStreamTagList(){
            return this.imageStreamTagList!=null;
    }

    public KubeSchemaFluent.ImageStreamTagListNested withNewImageStreamTagList(){
            return new ImageStreamTagListNestedImpl();
    }

    public KubeSchemaFluent.ImageStreamTagListNested withNewImageStreamTagListLike(ImageStreamTagList item){
            return new ImageStreamTagListNestedImpl(item);
    }

    public KubeSchemaFluent.ImageStreamTagListNested editImageStreamTagList(){
            return withNewImageStreamTagListLike(getImageStreamTagList());
    }

    public KubeSchemaFluent.ImageStreamTagListNested editOrNewImageStreamTagList(){
            return withNewImageStreamTagListLike(getImageStreamTagList() != null ? getImageStreamTagList(): new ImageStreamTagListBuilder().build());
    }

    public KubeSchemaFluent.ImageStreamTagListNested editOrNewImageStreamTagListLike(ImageStreamTagList item){
            return withNewImageStreamTagListLike(getImageStreamTagList() != null ? getImageStreamTagList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildInfo instead.
 */
@Deprecated public Info getInfo(){
            return this.info!=null?this.info.build():null;
    }

    public Info buildInfo(){
            return this.info!=null?this.info.build():null;
    }

    public A withInfo(Info info){
            _visitables.remove(this.info);
            if (info!=null){ this.info= new InfoBuilder(info); _visitables.add(this.info);} return (A) this;
    }

    public Boolean hasInfo(){
            return this.info!=null;
    }

    public KubeSchemaFluent.InfoNested withNewInfo(){
            return new InfoNestedImpl();
    }

    public KubeSchemaFluent.InfoNested withNewInfoLike(Info item){
            return new InfoNestedImpl(item);
    }

    public KubeSchemaFluent.InfoNested editInfo(){
            return withNewInfoLike(getInfo());
    }

    public KubeSchemaFluent.InfoNested editOrNewInfo(){
            return withNewInfoLike(getInfo() != null ? getInfo(): new InfoBuilder().build());
    }

    public KubeSchemaFluent.InfoNested editOrNewInfoLike(Info item){
            return withNewInfoLike(getInfo() != null ? getInfo(): item);
    }

    
/**
 * This method has been deprecated, please use method buildIngress instead.
 */
@Deprecated public Ingress getIngress(){
            return this.ingress!=null?this.ingress.build():null;
    }

    public Ingress buildIngress(){
            return this.ingress!=null?this.ingress.build():null;
    }

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

    public Boolean hasIngress(){
            return this.ingress!=null;
    }

    public KubeSchemaFluent.IngressNested withNewIngress(){
            return new IngressNestedImpl();
    }

    public KubeSchemaFluent.IngressNested withNewIngressLike(Ingress item){
            return new IngressNestedImpl(item);
    }

    public KubeSchemaFluent.IngressNested editIngress(){
            return withNewIngressLike(getIngress());
    }

    public KubeSchemaFluent.IngressNested editOrNewIngress(){
            return withNewIngressLike(getIngress() != null ? getIngress(): new IngressBuilder().build());
    }

    public KubeSchemaFluent.IngressNested editOrNewIngressLike(Ingress item){
            return withNewIngressLike(getIngress() != null ? getIngress(): item);
    }

    
/**
 * This method has been deprecated, please use method buildIngressList instead.
 */
@Deprecated public IngressList getIngressList(){
            return this.ingressList!=null?this.ingressList.build():null;
    }

    public IngressList buildIngressList(){
            return this.ingressList!=null?this.ingressList.build():null;
    }

    public A withIngressList(IngressList ingressList){
            _visitables.remove(this.ingressList);
            if (ingressList!=null){ this.ingressList= new IngressListBuilder(ingressList); _visitables.add(this.ingressList);} return (A) this;
    }

    public Boolean hasIngressList(){
            return this.ingressList!=null;
    }

    public KubeSchemaFluent.IngressListNested withNewIngressList(){
            return new IngressListNestedImpl();
    }

    public KubeSchemaFluent.IngressListNested withNewIngressListLike(IngressList item){
            return new IngressListNestedImpl(item);
    }

    public KubeSchemaFluent.IngressListNested editIngressList(){
            return withNewIngressListLike(getIngressList());
    }

    public KubeSchemaFluent.IngressListNested editOrNewIngressList(){
            return withNewIngressListLike(getIngressList() != null ? getIngressList(): new IngressListBuilder().build());
    }

    public KubeSchemaFluent.IngressListNested editOrNewIngressListLike(IngressList item){
            return withNewIngressListLike(getIngressList() != null ? getIngressList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildJenkins instead.
 */
@Deprecated public Jenkins getJenkins(){
            return this.jenkins!=null?this.jenkins.build():null;
    }

    public Jenkins buildJenkins(){
            return this.jenkins!=null?this.jenkins.build():null;
    }

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

    public Boolean hasJenkins(){
            return this.jenkins!=null;
    }

    public KubeSchemaFluent.JenkinsNested withNewJenkins(){
            return new JenkinsNestedImpl();
    }

    public KubeSchemaFluent.JenkinsNested withNewJenkinsLike(Jenkins item){
            return new JenkinsNestedImpl(item);
    }

    public KubeSchemaFluent.JenkinsNested editJenkins(){
            return withNewJenkinsLike(getJenkins());
    }

    public KubeSchemaFluent.JenkinsNested editOrNewJenkins(){
            return withNewJenkinsLike(getJenkins() != null ? getJenkins(): new JenkinsBuilder().build());
    }

    public KubeSchemaFluent.JenkinsNested editOrNewJenkinsLike(Jenkins item){
            return withNewJenkinsLike(getJenkins() != null ? getJenkins(): item);
    }

    
/**
 * This method has been deprecated, please use method buildJenkinsBinding instead.
 */
@Deprecated public JenkinsBinding getJenkinsBinding(){
            return this.jenkinsBinding!=null?this.jenkinsBinding.build():null;
    }

    public JenkinsBinding buildJenkinsBinding(){
            return this.jenkinsBinding!=null?this.jenkinsBinding.build():null;
    }

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

    public Boolean hasJenkinsBinding(){
            return this.jenkinsBinding!=null;
    }

    public KubeSchemaFluent.JenkinsBindingNested withNewJenkinsBinding(){
            return new JenkinsBindingNestedImpl();
    }

    public KubeSchemaFluent.JenkinsBindingNested withNewJenkinsBindingLike(JenkinsBinding item){
            return new JenkinsBindingNestedImpl(item);
    }

    public KubeSchemaFluent.JenkinsBindingNested editJenkinsBinding(){
            return withNewJenkinsBindingLike(getJenkinsBinding());
    }

    public KubeSchemaFluent.JenkinsBindingNested editOrNewJenkinsBinding(){
            return withNewJenkinsBindingLike(getJenkinsBinding() != null ? getJenkinsBinding(): new JenkinsBindingBuilder().build());
    }

    public KubeSchemaFluent.JenkinsBindingNested editOrNewJenkinsBindingLike(JenkinsBinding item){
            return withNewJenkinsBindingLike(getJenkinsBinding() != null ? getJenkinsBinding(): item);
    }

    
/**
 * This method has been deprecated, please use method buildJenkinsBindingList instead.
 */
@Deprecated public JenkinsBindingList getJenkinsBindingList(){
            return this.jenkinsBindingList!=null?this.jenkinsBindingList.build():null;
    }

    public JenkinsBindingList buildJenkinsBindingList(){
            return this.jenkinsBindingList!=null?this.jenkinsBindingList.build():null;
    }

    public A withJenkinsBindingList(JenkinsBindingList jenkinsBindingList){
            _visitables.remove(this.jenkinsBindingList);
            if (jenkinsBindingList!=null){ this.jenkinsBindingList= new JenkinsBindingListBuilder(jenkinsBindingList); _visitables.add(this.jenkinsBindingList);} return (A) this;
    }

    public Boolean hasJenkinsBindingList(){
            return this.jenkinsBindingList!=null;
    }

    public KubeSchemaFluent.JenkinsBindingListNested withNewJenkinsBindingList(){
            return new JenkinsBindingListNestedImpl();
    }

    public KubeSchemaFluent.JenkinsBindingListNested withNewJenkinsBindingListLike(JenkinsBindingList item){
            return new JenkinsBindingListNestedImpl(item);
    }

    public KubeSchemaFluent.JenkinsBindingListNested editJenkinsBindingList(){
            return withNewJenkinsBindingListLike(getJenkinsBindingList());
    }

    public KubeSchemaFluent.JenkinsBindingListNested editOrNewJenkinsBindingList(){
            return withNewJenkinsBindingListLike(getJenkinsBindingList() != null ? getJenkinsBindingList(): new JenkinsBindingListBuilder().build());
    }

    public KubeSchemaFluent.JenkinsBindingListNested editOrNewJenkinsBindingListLike(JenkinsBindingList item){
            return withNewJenkinsBindingListLike(getJenkinsBindingList() != null ? getJenkinsBindingList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildJenkinsList instead.
 */
@Deprecated public JenkinsList getJenkinsList(){
            return this.jenkinsList!=null?this.jenkinsList.build():null;
    }

    public JenkinsList buildJenkinsList(){
            return this.jenkinsList!=null?this.jenkinsList.build():null;
    }

    public A withJenkinsList(JenkinsList jenkinsList){
            _visitables.remove(this.jenkinsList);
            if (jenkinsList!=null){ this.jenkinsList= new JenkinsListBuilder(jenkinsList); _visitables.add(this.jenkinsList);} return (A) this;
    }

    public Boolean hasJenkinsList(){
            return this.jenkinsList!=null;
    }

    public KubeSchemaFluent.JenkinsListNested withNewJenkinsList(){
            return new JenkinsListNestedImpl();
    }

    public KubeSchemaFluent.JenkinsListNested withNewJenkinsListLike(JenkinsList item){
            return new JenkinsListNestedImpl(item);
    }

    public KubeSchemaFluent.JenkinsListNested editJenkinsList(){
            return withNewJenkinsListLike(getJenkinsList());
    }

    public KubeSchemaFluent.JenkinsListNested editOrNewJenkinsList(){
            return withNewJenkinsListLike(getJenkinsList() != null ? getJenkinsList(): new JenkinsListBuilder().build());
    }

    public KubeSchemaFluent.JenkinsListNested editOrNewJenkinsListLike(JenkinsList item){
            return withNewJenkinsListLike(getJenkinsList() != null ? getJenkinsList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildJob instead.
 */
@Deprecated public Job getJob(){
            return this.job!=null?this.job.build():null;
    }

    public Job buildJob(){
            return this.job!=null?this.job.build():null;
    }

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

    public Boolean hasJob(){
            return this.job!=null;
    }

    public KubeSchemaFluent.JobNested withNewJob(){
            return new JobNestedImpl();
    }

    public KubeSchemaFluent.JobNested withNewJobLike(Job item){
            return new JobNestedImpl(item);
    }

    public KubeSchemaFluent.JobNested editJob(){
            return withNewJobLike(getJob());
    }

    public KubeSchemaFluent.JobNested editOrNewJob(){
            return withNewJobLike(getJob() != null ? getJob(): new JobBuilder().build());
    }

    public KubeSchemaFluent.JobNested editOrNewJobLike(Job item){
            return withNewJobLike(getJob() != null ? getJob(): item);
    }

    
/**
 * This method has been deprecated, please use method buildJobList instead.
 */
@Deprecated public JobList getJobList(){
            return this.jobList!=null?this.jobList.build():null;
    }

    public JobList buildJobList(){
            return this.jobList!=null?this.jobList.build():null;
    }

    public A withJobList(JobList jobList){
            _visitables.remove(this.jobList);
            if (jobList!=null){ this.jobList= new JobListBuilder(jobList); _visitables.add(this.jobList);} return (A) this;
    }

    public Boolean hasJobList(){
            return this.jobList!=null;
    }

    public KubeSchemaFluent.JobListNested withNewJobList(){
            return new JobListNestedImpl();
    }

    public KubeSchemaFluent.JobListNested withNewJobListLike(JobList item){
            return new JobListNestedImpl(item);
    }

    public KubeSchemaFluent.JobListNested editJobList(){
            return withNewJobListLike(getJobList());
    }

    public KubeSchemaFluent.JobListNested editOrNewJobList(){
            return withNewJobListLike(getJobList() != null ? getJobList(): new JobListBuilder().build());
    }

    public KubeSchemaFluent.JobListNested editOrNewJobListLike(JobList item){
            return withNewJobListLike(getJobList() != null ? getJobList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildK8sLocalSubjectAccessReview instead.
 */
@Deprecated public io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview getK8sLocalSubjectAccessReview(){
            return this.k8sLocalSubjectAccessReview!=null?this.k8sLocalSubjectAccessReview.build():null;
    }

    public io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview buildK8sLocalSubjectAccessReview(){
            return this.k8sLocalSubjectAccessReview!=null?this.k8sLocalSubjectAccessReview.build():null;
    }

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

    public Boolean hasK8sLocalSubjectAccessReview(){
            return this.k8sLocalSubjectAccessReview!=null;
    }

    public KubeSchemaFluent.AuthorizationK8sLocalSubjectAccessReviewNested withNewAuthorizationK8sLocalSubjectAccessReview(){
            return new AuthorizationK8sLocalSubjectAccessReviewNestedImpl();
    }

    public KubeSchemaFluent.AuthorizationK8sLocalSubjectAccessReviewNested withNewK8sLocalSubjectAccessReviewLike(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
            return new AuthorizationK8sLocalSubjectAccessReviewNestedImpl(item);
    }

    public KubeSchemaFluent.AuthorizationK8sLocalSubjectAccessReviewNested editAuthorizationK8sLocalSubjectAccessReview(){
            return withNewK8sLocalSubjectAccessReviewLike(getK8sLocalSubjectAccessReview());
    }

    public KubeSchemaFluent.AuthorizationK8sLocalSubjectAccessReviewNested editOrNewK8sLocalSubjectAccessReview(){
            return withNewK8sLocalSubjectAccessReviewLike(getK8sLocalSubjectAccessReview() != null ? getK8sLocalSubjectAccessReview(): new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder().build());
    }

    public KubeSchemaFluent.AuthorizationK8sLocalSubjectAccessReviewNested editOrNewK8sLocalSubjectAccessReviewLike(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
            return withNewK8sLocalSubjectAccessReviewLike(getK8sLocalSubjectAccessReview() != null ? getK8sLocalSubjectAccessReview(): item);
    }

    
/**
 * This method has been deprecated, please use method buildK8sSubjectAccessReview instead.
 */
@Deprecated public io.alauda.kubernetes.api.model.authorization.SubjectAccessReview getK8sSubjectAccessReview(){
            return this.k8sSubjectAccessReview!=null?this.k8sSubjectAccessReview.build():null;
    }

    public io.alauda.kubernetes.api.model.authorization.SubjectAccessReview buildK8sSubjectAccessReview(){
            return this.k8sSubjectAccessReview!=null?this.k8sSubjectAccessReview.build():null;
    }

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

    public Boolean hasK8sSubjectAccessReview(){
            return this.k8sSubjectAccessReview!=null;
    }

    public KubeSchemaFluent.AuthorizationK8sSubjectAccessReviewNested withNewAuthorizationK8sSubjectAccessReview(){
            return new AuthorizationK8sSubjectAccessReviewNestedImpl();
    }

    public KubeSchemaFluent.AuthorizationK8sSubjectAccessReviewNested withNewK8sSubjectAccessReviewLike(io.alauda.kubernetes.api.model.authorization.SubjectAccessReview item){
            return new AuthorizationK8sSubjectAccessReviewNestedImpl(item);
    }

    public KubeSchemaFluent.AuthorizationK8sSubjectAccessReviewNested editAuthorizationK8sSubjectAccessReview(){
            return withNewK8sSubjectAccessReviewLike(getK8sSubjectAccessReview());
    }

    public KubeSchemaFluent.AuthorizationK8sSubjectAccessReviewNested editOrNewK8sSubjectAccessReview(){
            return withNewK8sSubjectAccessReviewLike(getK8sSubjectAccessReview() != null ? getK8sSubjectAccessReview(): new io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder().build());
    }

    public KubeSchemaFluent.AuthorizationK8sSubjectAccessReviewNested editOrNewK8sSubjectAccessReviewLike(io.alauda.kubernetes.api.model.authorization.SubjectAccessReview item){
            return withNewK8sSubjectAccessReviewLike(getK8sSubjectAccessReview() != null ? getK8sSubjectAccessReview(): item);
    }

    
/**
 * This method has been deprecated, please use method buildLimitRangeList instead.
 */
@Deprecated public LimitRangeList getLimitRangeList(){
            return this.limitRangeList!=null?this.limitRangeList.build():null;
    }

    public LimitRangeList buildLimitRangeList(){
            return this.limitRangeList!=null?this.limitRangeList.build():null;
    }

    public A withLimitRangeList(LimitRangeList limitRangeList){
            _visitables.remove(this.limitRangeList);
            if (limitRangeList!=null){ this.limitRangeList= new LimitRangeListBuilder(limitRangeList); _visitables.add(this.limitRangeList);} return (A) this;
    }

    public Boolean hasLimitRangeList(){
            return this.limitRangeList!=null;
    }

    public KubeSchemaFluent.LimitRangeListNested withNewLimitRangeList(){
            return new LimitRangeListNestedImpl();
    }

    public KubeSchemaFluent.LimitRangeListNested withNewLimitRangeListLike(LimitRangeList item){
            return new LimitRangeListNestedImpl(item);
    }

    public KubeSchemaFluent.LimitRangeListNested editLimitRangeList(){
            return withNewLimitRangeListLike(getLimitRangeList());
    }

    public KubeSchemaFluent.LimitRangeListNested editOrNewLimitRangeList(){
            return withNewLimitRangeListLike(getLimitRangeList() != null ? getLimitRangeList(): new LimitRangeListBuilder().build());
    }

    public KubeSchemaFluent.LimitRangeListNested editOrNewLimitRangeListLike(LimitRangeList item){
            return withNewLimitRangeListLike(getLimitRangeList() != null ? getLimitRangeList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildListMeta instead.
 */
@Deprecated public ListMeta getListMeta(){
            return this.listMeta!=null?this.listMeta.build():null;
    }

    public ListMeta buildListMeta(){
            return this.listMeta!=null?this.listMeta.build():null;
    }

    public A withListMeta(ListMeta listMeta){
            _visitables.remove(this.listMeta);
            if (listMeta!=null){ this.listMeta= new ListMetaBuilder(listMeta); _visitables.add(this.listMeta);} return (A) this;
    }

    public Boolean hasListMeta(){
            return this.listMeta!=null;
    }

    public KubeSchemaFluent.ListMetaNested withNewListMeta(){
            return new ListMetaNestedImpl();
    }

    public KubeSchemaFluent.ListMetaNested withNewListMetaLike(ListMeta item){
            return new ListMetaNestedImpl(item);
    }

    public KubeSchemaFluent.ListMetaNested editListMeta(){
            return withNewListMetaLike(getListMeta());
    }

    public KubeSchemaFluent.ListMetaNested editOrNewListMeta(){
            return withNewListMetaLike(getListMeta() != null ? getListMeta(): new ListMetaBuilder().build());
    }

    public KubeSchemaFluent.ListMetaNested editOrNewListMetaLike(ListMeta item){
            return withNewListMetaLike(getListMeta() != null ? getListMeta(): item);
    }

    public A withNewListMeta(String resourceVersion,String selfLink){
            return (A)withListMeta(new ListMeta(resourceVersion, selfLink));
    }

    
/**
 * This method has been deprecated, please use method buildLocalSubjectAccessReview instead.
 */
@Deprecated public LocalSubjectAccessReview getLocalSubjectAccessReview(){
            return this.localSubjectAccessReview!=null?this.localSubjectAccessReview.build():null;
    }

    public LocalSubjectAccessReview buildLocalSubjectAccessReview(){
            return this.localSubjectAccessReview!=null?this.localSubjectAccessReview.build():null;
    }

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

    public Boolean hasLocalSubjectAccessReview(){
            return this.localSubjectAccessReview!=null;
    }

    public KubeSchemaFluent.LocalSubjectAccessReviewNested withNewLocalSubjectAccessReview(){
            return new LocalSubjectAccessReviewNestedImpl();
    }

    public KubeSchemaFluent.LocalSubjectAccessReviewNested withNewLocalSubjectAccessReviewLike(LocalSubjectAccessReview item){
            return new LocalSubjectAccessReviewNestedImpl(item);
    }

    public KubeSchemaFluent.LocalSubjectAccessReviewNested editLocalSubjectAccessReview(){
            return withNewLocalSubjectAccessReviewLike(getLocalSubjectAccessReview());
    }

    public KubeSchemaFluent.LocalSubjectAccessReviewNested editOrNewLocalSubjectAccessReview(){
            return withNewLocalSubjectAccessReviewLike(getLocalSubjectAccessReview() != null ? getLocalSubjectAccessReview(): new LocalSubjectAccessReviewBuilder().build());
    }

    public KubeSchemaFluent.LocalSubjectAccessReviewNested editOrNewLocalSubjectAccessReviewLike(LocalSubjectAccessReview item){
            return withNewLocalSubjectAccessReviewLike(getLocalSubjectAccessReview() != null ? getLocalSubjectAccessReview(): item);
    }

    
/**
 * This method has been deprecated, please use method buildNamespace instead.
 */
@Deprecated public Namespace getNamespace(){
            return this.namespace!=null?this.namespace.build():null;
    }

    public Namespace buildNamespace(){
            return this.namespace!=null?this.namespace.build():null;
    }

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

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

    public KubeSchemaFluent.NamespaceNested withNewNamespace(){
            return new NamespaceNestedImpl();
    }

    public KubeSchemaFluent.NamespaceNested withNewNamespaceLike(Namespace item){
            return new NamespaceNestedImpl(item);
    }

    public KubeSchemaFluent.NamespaceNested editNamespace(){
            return withNewNamespaceLike(getNamespace());
    }

    public KubeSchemaFluent.NamespaceNested editOrNewNamespace(){
            return withNewNamespaceLike(getNamespace() != null ? getNamespace(): new NamespaceBuilder().build());
    }

    public KubeSchemaFluent.NamespaceNested editOrNewNamespaceLike(Namespace item){
            return withNewNamespaceLike(getNamespace() != null ? getNamespace(): item);
    }

    
/**
 * This method has been deprecated, please use method buildNamespaceList instead.
 */
@Deprecated public NamespaceList getNamespaceList(){
            return this.namespaceList!=null?this.namespaceList.build():null;
    }

    public NamespaceList buildNamespaceList(){
            return this.namespaceList!=null?this.namespaceList.build():null;
    }

    public A withNamespaceList(NamespaceList namespaceList){
            _visitables.remove(this.namespaceList);
            if (namespaceList!=null){ this.namespaceList= new NamespaceListBuilder(namespaceList); _visitables.add(this.namespaceList);} return (A) this;
    }

    public Boolean hasNamespaceList(){
            return this.namespaceList!=null;
    }

    public KubeSchemaFluent.NamespaceListNested withNewNamespaceList(){
            return new NamespaceListNestedImpl();
    }

    public KubeSchemaFluent.NamespaceListNested withNewNamespaceListLike(NamespaceList item){
            return new NamespaceListNestedImpl(item);
    }

    public KubeSchemaFluent.NamespaceListNested editNamespaceList(){
            return withNewNamespaceListLike(getNamespaceList());
    }

    public KubeSchemaFluent.NamespaceListNested editOrNewNamespaceList(){
            return withNewNamespaceListLike(getNamespaceList() != null ? getNamespaceList(): new NamespaceListBuilder().build());
    }

    public KubeSchemaFluent.NamespaceListNested editOrNewNamespaceListLike(NamespaceList item){
            return withNewNamespaceListLike(getNamespaceList() != null ? getNamespaceList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildNetworkPolicy instead.
 */
@Deprecated public NetworkPolicy getNetworkPolicy(){
            return this.networkPolicy!=null?this.networkPolicy.build():null;
    }

    public NetworkPolicy buildNetworkPolicy(){
            return this.networkPolicy!=null?this.networkPolicy.build():null;
    }

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

    public Boolean hasNetworkPolicy(){
            return this.networkPolicy!=null;
    }

    public KubeSchemaFluent.NetworkPolicyNested withNewNetworkPolicy(){
            return new NetworkPolicyNestedImpl();
    }

    public KubeSchemaFluent.NetworkPolicyNested withNewNetworkPolicyLike(NetworkPolicy item){
            return new NetworkPolicyNestedImpl(item);
    }

    public KubeSchemaFluent.NetworkPolicyNested editNetworkPolicy(){
            return withNewNetworkPolicyLike(getNetworkPolicy());
    }

    public KubeSchemaFluent.NetworkPolicyNested editOrNewNetworkPolicy(){
            return withNewNetworkPolicyLike(getNetworkPolicy() != null ? getNetworkPolicy(): new NetworkPolicyBuilder().build());
    }

    public KubeSchemaFluent.NetworkPolicyNested editOrNewNetworkPolicyLike(NetworkPolicy item){
            return withNewNetworkPolicyLike(getNetworkPolicy() != null ? getNetworkPolicy(): item);
    }

    
/**
 * This method has been deprecated, please use method buildNetworkPolicyList instead.
 */
@Deprecated public NetworkPolicyList getNetworkPolicyList(){
            return this.networkPolicyList!=null?this.networkPolicyList.build():null;
    }

    public NetworkPolicyList buildNetworkPolicyList(){
            return this.networkPolicyList!=null?this.networkPolicyList.build():null;
    }

    public A withNetworkPolicyList(NetworkPolicyList networkPolicyList){
            _visitables.remove(this.networkPolicyList);
            if (networkPolicyList!=null){ this.networkPolicyList= new NetworkPolicyListBuilder(networkPolicyList); _visitables.add(this.networkPolicyList);} return (A) this;
    }

    public Boolean hasNetworkPolicyList(){
            return this.networkPolicyList!=null;
    }

    public KubeSchemaFluent.NetworkPolicyListNested withNewNetworkPolicyList(){
            return new NetworkPolicyListNestedImpl();
    }

    public KubeSchemaFluent.NetworkPolicyListNested withNewNetworkPolicyListLike(NetworkPolicyList item){
            return new NetworkPolicyListNestedImpl(item);
    }

    public KubeSchemaFluent.NetworkPolicyListNested editNetworkPolicyList(){
            return withNewNetworkPolicyListLike(getNetworkPolicyList());
    }

    public KubeSchemaFluent.NetworkPolicyListNested editOrNewNetworkPolicyList(){
            return withNewNetworkPolicyListLike(getNetworkPolicyList() != null ? getNetworkPolicyList(): new NetworkPolicyListBuilder().build());
    }

    public KubeSchemaFluent.NetworkPolicyListNested editOrNewNetworkPolicyListLike(NetworkPolicyList item){
            return withNewNetworkPolicyListLike(getNetworkPolicyList() != null ? getNetworkPolicyList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildNode instead.
 */
@Deprecated public Node getNode(){
            return this.node!=null?this.node.build():null;
    }

    public Node buildNode(){
            return this.node!=null?this.node.build():null;
    }

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

    public Boolean hasNode(){
            return this.node!=null;
    }

    public KubeSchemaFluent.NodeNested withNewNode(){
            return new NodeNestedImpl();
    }

    public KubeSchemaFluent.NodeNested withNewNodeLike(Node item){
            return new NodeNestedImpl(item);
    }

    public KubeSchemaFluent.NodeNested editNode(){
            return withNewNodeLike(getNode());
    }

    public KubeSchemaFluent.NodeNested editOrNewNode(){
            return withNewNodeLike(getNode() != null ? getNode(): new NodeBuilder().build());
    }

    public KubeSchemaFluent.NodeNested editOrNewNodeLike(Node item){
            return withNewNodeLike(getNode() != null ? getNode(): item);
    }

    
/**
 * This method has been deprecated, please use method buildNodeList instead.
 */
@Deprecated public NodeList getNodeList(){
            return this.nodeList!=null?this.nodeList.build():null;
    }

    public NodeList buildNodeList(){
            return this.nodeList!=null?this.nodeList.build():null;
    }

    public A withNodeList(NodeList nodeList){
            _visitables.remove(this.nodeList);
            if (nodeList!=null){ this.nodeList= new NodeListBuilder(nodeList); _visitables.add(this.nodeList);} return (A) this;
    }

    public Boolean hasNodeList(){
            return this.nodeList!=null;
    }

    public KubeSchemaFluent.NodeListNested withNewNodeList(){
            return new NodeListNestedImpl();
    }

    public KubeSchemaFluent.NodeListNested withNewNodeListLike(NodeList item){
            return new NodeListNestedImpl(item);
    }

    public KubeSchemaFluent.NodeListNested editNodeList(){
            return withNewNodeListLike(getNodeList());
    }

    public KubeSchemaFluent.NodeListNested editOrNewNodeList(){
            return withNewNodeListLike(getNodeList() != null ? getNodeList(): new NodeListBuilder().build());
    }

    public KubeSchemaFluent.NodeListNested editOrNewNodeListLike(NodeList item){
            return withNewNodeListLike(getNodeList() != null ? getNodeList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthAccessToken instead.
 */
@Deprecated public OAuthAccessToken getOAuthAccessToken(){
            return this.oAuthAccessToken!=null?this.oAuthAccessToken.build():null;
    }

    public OAuthAccessToken buildOAuthAccessToken(){
            return this.oAuthAccessToken!=null?this.oAuthAccessToken.build():null;
    }

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

    public Boolean hasOAuthAccessToken(){
            return this.oAuthAccessToken!=null;
    }

    public KubeSchemaFluent.OAuthAccessTokenNested withNewOAuthAccessToken(){
            return new OAuthAccessTokenNestedImpl();
    }

    public KubeSchemaFluent.OAuthAccessTokenNested withNewOAuthAccessTokenLike(OAuthAccessToken item){
            return new OAuthAccessTokenNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthAccessTokenNested editOAuthAccessToken(){
            return withNewOAuthAccessTokenLike(getOAuthAccessToken());
    }

    public KubeSchemaFluent.OAuthAccessTokenNested editOrNewOAuthAccessToken(){
            return withNewOAuthAccessTokenLike(getOAuthAccessToken() != null ? getOAuthAccessToken(): new OAuthAccessTokenBuilder().build());
    }

    public KubeSchemaFluent.OAuthAccessTokenNested editOrNewOAuthAccessTokenLike(OAuthAccessToken item){
            return withNewOAuthAccessTokenLike(getOAuthAccessToken() != null ? getOAuthAccessToken(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthAccessTokenList instead.
 */
@Deprecated public OAuthAccessTokenList getOAuthAccessTokenList(){
            return this.oAuthAccessTokenList!=null?this.oAuthAccessTokenList.build():null;
    }

    public OAuthAccessTokenList buildOAuthAccessTokenList(){
            return this.oAuthAccessTokenList!=null?this.oAuthAccessTokenList.build():null;
    }

    public A withOAuthAccessTokenList(OAuthAccessTokenList oAuthAccessTokenList){
            _visitables.remove(this.oAuthAccessTokenList);
            if (oAuthAccessTokenList!=null){ this.oAuthAccessTokenList= new OAuthAccessTokenListBuilder(oAuthAccessTokenList); _visitables.add(this.oAuthAccessTokenList);} return (A) this;
    }

    public Boolean hasOAuthAccessTokenList(){
            return this.oAuthAccessTokenList!=null;
    }

    public KubeSchemaFluent.OAuthAccessTokenListNested withNewOAuthAccessTokenList(){
            return new OAuthAccessTokenListNestedImpl();
    }

    public KubeSchemaFluent.OAuthAccessTokenListNested withNewOAuthAccessTokenListLike(OAuthAccessTokenList item){
            return new OAuthAccessTokenListNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthAccessTokenListNested editOAuthAccessTokenList(){
            return withNewOAuthAccessTokenListLike(getOAuthAccessTokenList());
    }

    public KubeSchemaFluent.OAuthAccessTokenListNested editOrNewOAuthAccessTokenList(){
            return withNewOAuthAccessTokenListLike(getOAuthAccessTokenList() != null ? getOAuthAccessTokenList(): new OAuthAccessTokenListBuilder().build());
    }

    public KubeSchemaFluent.OAuthAccessTokenListNested editOrNewOAuthAccessTokenListLike(OAuthAccessTokenList item){
            return withNewOAuthAccessTokenListLike(getOAuthAccessTokenList() != null ? getOAuthAccessTokenList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthAuthorizeToken instead.
 */
@Deprecated public OAuthAuthorizeToken getOAuthAuthorizeToken(){
            return this.oAuthAuthorizeToken!=null?this.oAuthAuthorizeToken.build():null;
    }

    public OAuthAuthorizeToken buildOAuthAuthorizeToken(){
            return this.oAuthAuthorizeToken!=null?this.oAuthAuthorizeToken.build():null;
    }

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

    public Boolean hasOAuthAuthorizeToken(){
            return this.oAuthAuthorizeToken!=null;
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenNested withNewOAuthAuthorizeToken(){
            return new OAuthAuthorizeTokenNestedImpl();
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenNested withNewOAuthAuthorizeTokenLike(OAuthAuthorizeToken item){
            return new OAuthAuthorizeTokenNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenNested editOAuthAuthorizeToken(){
            return withNewOAuthAuthorizeTokenLike(getOAuthAuthorizeToken());
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenNested editOrNewOAuthAuthorizeToken(){
            return withNewOAuthAuthorizeTokenLike(getOAuthAuthorizeToken() != null ? getOAuthAuthorizeToken(): new OAuthAuthorizeTokenBuilder().build());
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenNested editOrNewOAuthAuthorizeTokenLike(OAuthAuthorizeToken item){
            return withNewOAuthAuthorizeTokenLike(getOAuthAuthorizeToken() != null ? getOAuthAuthorizeToken(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthAuthorizeTokenList instead.
 */
@Deprecated public OAuthAuthorizeTokenList getOAuthAuthorizeTokenList(){
            return this.oAuthAuthorizeTokenList!=null?this.oAuthAuthorizeTokenList.build():null;
    }

    public OAuthAuthorizeTokenList buildOAuthAuthorizeTokenList(){
            return this.oAuthAuthorizeTokenList!=null?this.oAuthAuthorizeTokenList.build():null;
    }

    public A withOAuthAuthorizeTokenList(OAuthAuthorizeTokenList oAuthAuthorizeTokenList){
            _visitables.remove(this.oAuthAuthorizeTokenList);
            if (oAuthAuthorizeTokenList!=null){ this.oAuthAuthorizeTokenList= new OAuthAuthorizeTokenListBuilder(oAuthAuthorizeTokenList); _visitables.add(this.oAuthAuthorizeTokenList);} return (A) this;
    }

    public Boolean hasOAuthAuthorizeTokenList(){
            return this.oAuthAuthorizeTokenList!=null;
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenListNested withNewOAuthAuthorizeTokenList(){
            return new OAuthAuthorizeTokenListNestedImpl();
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenListNested withNewOAuthAuthorizeTokenListLike(OAuthAuthorizeTokenList item){
            return new OAuthAuthorizeTokenListNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenListNested editOAuthAuthorizeTokenList(){
            return withNewOAuthAuthorizeTokenListLike(getOAuthAuthorizeTokenList());
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenListNested editOrNewOAuthAuthorizeTokenList(){
            return withNewOAuthAuthorizeTokenListLike(getOAuthAuthorizeTokenList() != null ? getOAuthAuthorizeTokenList(): new OAuthAuthorizeTokenListBuilder().build());
    }

    public KubeSchemaFluent.OAuthAuthorizeTokenListNested editOrNewOAuthAuthorizeTokenListLike(OAuthAuthorizeTokenList item){
            return withNewOAuthAuthorizeTokenListLike(getOAuthAuthorizeTokenList() != null ? getOAuthAuthorizeTokenList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthClient instead.
 */
@Deprecated public OAuthClient getOAuthClient(){
            return this.oAuthClient!=null?this.oAuthClient.build():null;
    }

    public OAuthClient buildOAuthClient(){
            return this.oAuthClient!=null?this.oAuthClient.build():null;
    }

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

    public Boolean hasOAuthClient(){
            return this.oAuthClient!=null;
    }

    public KubeSchemaFluent.OAuthClientNested withNewOAuthClient(){
            return new OAuthClientNestedImpl();
    }

    public KubeSchemaFluent.OAuthClientNested withNewOAuthClientLike(OAuthClient item){
            return new OAuthClientNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthClientNested editOAuthClient(){
            return withNewOAuthClientLike(getOAuthClient());
    }

    public KubeSchemaFluent.OAuthClientNested editOrNewOAuthClient(){
            return withNewOAuthClientLike(getOAuthClient() != null ? getOAuthClient(): new OAuthClientBuilder().build());
    }

    public KubeSchemaFluent.OAuthClientNested editOrNewOAuthClientLike(OAuthClient item){
            return withNewOAuthClientLike(getOAuthClient() != null ? getOAuthClient(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthClientAuthorization instead.
 */
@Deprecated public OAuthClientAuthorization getOAuthClientAuthorization(){
            return this.oAuthClientAuthorization!=null?this.oAuthClientAuthorization.build():null;
    }

    public OAuthClientAuthorization buildOAuthClientAuthorization(){
            return this.oAuthClientAuthorization!=null?this.oAuthClientAuthorization.build():null;
    }

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

    public Boolean hasOAuthClientAuthorization(){
            return this.oAuthClientAuthorization!=null;
    }

    public KubeSchemaFluent.OAuthClientAuthorizationNested withNewOAuthClientAuthorization(){
            return new OAuthClientAuthorizationNestedImpl();
    }

    public KubeSchemaFluent.OAuthClientAuthorizationNested withNewOAuthClientAuthorizationLike(OAuthClientAuthorization item){
            return new OAuthClientAuthorizationNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthClientAuthorizationNested editOAuthClientAuthorization(){
            return withNewOAuthClientAuthorizationLike(getOAuthClientAuthorization());
    }

    public KubeSchemaFluent.OAuthClientAuthorizationNested editOrNewOAuthClientAuthorization(){
            return withNewOAuthClientAuthorizationLike(getOAuthClientAuthorization() != null ? getOAuthClientAuthorization(): new OAuthClientAuthorizationBuilder().build());
    }

    public KubeSchemaFluent.OAuthClientAuthorizationNested editOrNewOAuthClientAuthorizationLike(OAuthClientAuthorization item){
            return withNewOAuthClientAuthorizationLike(getOAuthClientAuthorization() != null ? getOAuthClientAuthorization(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthClientAuthorizationList instead.
 */
@Deprecated public OAuthClientAuthorizationList getOAuthClientAuthorizationList(){
            return this.oAuthClientAuthorizationList!=null?this.oAuthClientAuthorizationList.build():null;
    }

    public OAuthClientAuthorizationList buildOAuthClientAuthorizationList(){
            return this.oAuthClientAuthorizationList!=null?this.oAuthClientAuthorizationList.build():null;
    }

    public A withOAuthClientAuthorizationList(OAuthClientAuthorizationList oAuthClientAuthorizationList){
            _visitables.remove(this.oAuthClientAuthorizationList);
            if (oAuthClientAuthorizationList!=null){ this.oAuthClientAuthorizationList= new OAuthClientAuthorizationListBuilder(oAuthClientAuthorizationList); _visitables.add(this.oAuthClientAuthorizationList);} return (A) this;
    }

    public Boolean hasOAuthClientAuthorizationList(){
            return this.oAuthClientAuthorizationList!=null;
    }

    public KubeSchemaFluent.OAuthClientAuthorizationListNested withNewOAuthClientAuthorizationList(){
            return new OAuthClientAuthorizationListNestedImpl();
    }

    public KubeSchemaFluent.OAuthClientAuthorizationListNested withNewOAuthClientAuthorizationListLike(OAuthClientAuthorizationList item){
            return new OAuthClientAuthorizationListNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthClientAuthorizationListNested editOAuthClientAuthorizationList(){
            return withNewOAuthClientAuthorizationListLike(getOAuthClientAuthorizationList());
    }

    public KubeSchemaFluent.OAuthClientAuthorizationListNested editOrNewOAuthClientAuthorizationList(){
            return withNewOAuthClientAuthorizationListLike(getOAuthClientAuthorizationList() != null ? getOAuthClientAuthorizationList(): new OAuthClientAuthorizationListBuilder().build());
    }

    public KubeSchemaFluent.OAuthClientAuthorizationListNested editOrNewOAuthClientAuthorizationListLike(OAuthClientAuthorizationList item){
            return withNewOAuthClientAuthorizationListLike(getOAuthClientAuthorizationList() != null ? getOAuthClientAuthorizationList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildOAuthClientList instead.
 */
@Deprecated public OAuthClientList getOAuthClientList(){
            return this.oAuthClientList!=null?this.oAuthClientList.build():null;
    }

    public OAuthClientList buildOAuthClientList(){
            return this.oAuthClientList!=null?this.oAuthClientList.build():null;
    }

    public A withOAuthClientList(OAuthClientList oAuthClientList){
            _visitables.remove(this.oAuthClientList);
            if (oAuthClientList!=null){ this.oAuthClientList= new OAuthClientListBuilder(oAuthClientList); _visitables.add(this.oAuthClientList);} return (A) this;
    }

    public Boolean hasOAuthClientList(){
            return this.oAuthClientList!=null;
    }

    public KubeSchemaFluent.OAuthClientListNested withNewOAuthClientList(){
            return new OAuthClientListNestedImpl();
    }

    public KubeSchemaFluent.OAuthClientListNested withNewOAuthClientListLike(OAuthClientList item){
            return new OAuthClientListNestedImpl(item);
    }

    public KubeSchemaFluent.OAuthClientListNested editOAuthClientList(){
            return withNewOAuthClientListLike(getOAuthClientList());
    }

    public KubeSchemaFluent.OAuthClientListNested editOrNewOAuthClientList(){
            return withNewOAuthClientListLike(getOAuthClientList() != null ? getOAuthClientList(): new OAuthClientListBuilder().build());
    }

    public KubeSchemaFluent.OAuthClientListNested editOrNewOAuthClientListLike(OAuthClientList item){
            return withNewOAuthClientListLike(getOAuthClientList() != null ? getOAuthClientList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildObjectMeta instead.
 */
@Deprecated public ObjectMeta getObjectMeta(){
            return this.objectMeta!=null?this.objectMeta.build():null;
    }

    public ObjectMeta buildObjectMeta(){
            return this.objectMeta!=null?this.objectMeta.build():null;
    }

    public A withObjectMeta(ObjectMeta objectMeta){
            _visitables.remove(this.objectMeta);
            if (objectMeta!=null){ this.objectMeta= new ObjectMetaBuilder(objectMeta); _visitables.add(this.objectMeta);} return (A) this;
    }

    public Boolean hasObjectMeta(){
            return this.objectMeta!=null;
    }

    public KubeSchemaFluent.ObjectMetaNested withNewObjectMeta(){
            return new ObjectMetaNestedImpl();
    }

    public KubeSchemaFluent.ObjectMetaNested withNewObjectMetaLike(ObjectMeta item){
            return new ObjectMetaNestedImpl(item);
    }

    public KubeSchemaFluent.ObjectMetaNested editObjectMeta(){
            return withNewObjectMetaLike(getObjectMeta());
    }

    public KubeSchemaFluent.ObjectMetaNested editOrNewObjectMeta(){
            return withNewObjectMetaLike(getObjectMeta() != null ? getObjectMeta(): new ObjectMetaBuilder().build());
    }

    public KubeSchemaFluent.ObjectMetaNested editOrNewObjectMetaLike(ObjectMeta item){
            return withNewObjectMetaLike(getObjectMeta() != null ? getObjectMeta(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPatch instead.
 */
@Deprecated public Patch getPatch(){
            return this.patch!=null?this.patch.build():null;
    }

    public Patch buildPatch(){
            return this.patch!=null?this.patch.build():null;
    }

    public A withPatch(Patch patch){
            _visitables.remove(this.patch);
            if (patch!=null){ this.patch= new PatchBuilder(patch); _visitables.add(this.patch);} return (A) this;
    }

    public Boolean hasPatch(){
            return this.patch!=null;
    }

    public KubeSchemaFluent.PatchNested withNewPatch(){
            return new PatchNestedImpl();
    }

    public KubeSchemaFluent.PatchNested withNewPatchLike(Patch item){
            return new PatchNestedImpl(item);
    }

    public KubeSchemaFluent.PatchNested editPatch(){
            return withNewPatchLike(getPatch());
    }

    public KubeSchemaFluent.PatchNested editOrNewPatch(){
            return withNewPatchLike(getPatch() != null ? getPatch(): new PatchBuilder().build());
    }

    public KubeSchemaFluent.PatchNested editOrNewPatchLike(Patch item){
            return withNewPatchLike(getPatch() != null ? getPatch(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPersistentVolume instead.
 */
@Deprecated public PersistentVolume getPersistentVolume(){
            return this.persistentVolume!=null?this.persistentVolume.build():null;
    }

    public PersistentVolume buildPersistentVolume(){
            return this.persistentVolume!=null?this.persistentVolume.build():null;
    }

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

    public Boolean hasPersistentVolume(){
            return this.persistentVolume!=null;
    }

    public KubeSchemaFluent.PersistentVolumeNested withNewPersistentVolume(){
            return new PersistentVolumeNestedImpl();
    }

    public KubeSchemaFluent.PersistentVolumeNested withNewPersistentVolumeLike(PersistentVolume item){
            return new PersistentVolumeNestedImpl(item);
    }

    public KubeSchemaFluent.PersistentVolumeNested editPersistentVolume(){
            return withNewPersistentVolumeLike(getPersistentVolume());
    }

    public KubeSchemaFluent.PersistentVolumeNested editOrNewPersistentVolume(){
            return withNewPersistentVolumeLike(getPersistentVolume() != null ? getPersistentVolume(): new PersistentVolumeBuilder().build());
    }

    public KubeSchemaFluent.PersistentVolumeNested editOrNewPersistentVolumeLike(PersistentVolume item){
            return withNewPersistentVolumeLike(getPersistentVolume() != null ? getPersistentVolume(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPersistentVolumeClaim instead.
 */
@Deprecated public PersistentVolumeClaim getPersistentVolumeClaim(){
            return this.persistentVolumeClaim!=null?this.persistentVolumeClaim.build():null;
    }

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

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

    public Boolean hasPersistentVolumeClaim(){
            return this.persistentVolumeClaim!=null;
    }

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

    public KubeSchemaFluent.PersistentVolumeClaimNested withNewPersistentVolumeClaimLike(PersistentVolumeClaim item){
            return new PersistentVolumeClaimNestedImpl(item);
    }

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

    public KubeSchemaFluent.PersistentVolumeClaimNested editOrNewPersistentVolumeClaim(){
            return withNewPersistentVolumeClaimLike(getPersistentVolumeClaim() != null ? getPersistentVolumeClaim(): new PersistentVolumeClaimBuilder().build());
    }

    public KubeSchemaFluent.PersistentVolumeClaimNested editOrNewPersistentVolumeClaimLike(PersistentVolumeClaim item){
            return withNewPersistentVolumeClaimLike(getPersistentVolumeClaim() != null ? getPersistentVolumeClaim(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPersistentVolumeClaimList instead.
 */
@Deprecated public PersistentVolumeClaimList getPersistentVolumeClaimList(){
            return this.persistentVolumeClaimList!=null?this.persistentVolumeClaimList.build():null;
    }

    public PersistentVolumeClaimList buildPersistentVolumeClaimList(){
            return this.persistentVolumeClaimList!=null?this.persistentVolumeClaimList.build():null;
    }

    public A withPersistentVolumeClaimList(PersistentVolumeClaimList persistentVolumeClaimList){
            _visitables.remove(this.persistentVolumeClaimList);
            if (persistentVolumeClaimList!=null){ this.persistentVolumeClaimList= new PersistentVolumeClaimListBuilder(persistentVolumeClaimList); _visitables.add(this.persistentVolumeClaimList);} return (A) this;
    }

    public Boolean hasPersistentVolumeClaimList(){
            return this.persistentVolumeClaimList!=null;
    }

    public KubeSchemaFluent.PersistentVolumeClaimListNested withNewPersistentVolumeClaimList(){
            return new PersistentVolumeClaimListNestedImpl();
    }

    public KubeSchemaFluent.PersistentVolumeClaimListNested withNewPersistentVolumeClaimListLike(PersistentVolumeClaimList item){
            return new PersistentVolumeClaimListNestedImpl(item);
    }

    public KubeSchemaFluent.PersistentVolumeClaimListNested editPersistentVolumeClaimList(){
            return withNewPersistentVolumeClaimListLike(getPersistentVolumeClaimList());
    }

    public KubeSchemaFluent.PersistentVolumeClaimListNested editOrNewPersistentVolumeClaimList(){
            return withNewPersistentVolumeClaimListLike(getPersistentVolumeClaimList() != null ? getPersistentVolumeClaimList(): new PersistentVolumeClaimListBuilder().build());
    }

    public KubeSchemaFluent.PersistentVolumeClaimListNested editOrNewPersistentVolumeClaimListLike(PersistentVolumeClaimList item){
            return withNewPersistentVolumeClaimListLike(getPersistentVolumeClaimList() != null ? getPersistentVolumeClaimList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPersistentVolumeList instead.
 */
@Deprecated public PersistentVolumeList getPersistentVolumeList(){
            return this.persistentVolumeList!=null?this.persistentVolumeList.build():null;
    }

    public PersistentVolumeList buildPersistentVolumeList(){
            return this.persistentVolumeList!=null?this.persistentVolumeList.build():null;
    }

    public A withPersistentVolumeList(PersistentVolumeList persistentVolumeList){
            _visitables.remove(this.persistentVolumeList);
            if (persistentVolumeList!=null){ this.persistentVolumeList= new PersistentVolumeListBuilder(persistentVolumeList); _visitables.add(this.persistentVolumeList);} return (A) this;
    }

    public Boolean hasPersistentVolumeList(){
            return this.persistentVolumeList!=null;
    }

    public KubeSchemaFluent.PersistentVolumeListNested withNewPersistentVolumeList(){
            return new PersistentVolumeListNestedImpl();
    }

    public KubeSchemaFluent.PersistentVolumeListNested withNewPersistentVolumeListLike(PersistentVolumeList item){
            return new PersistentVolumeListNestedImpl(item);
    }

    public KubeSchemaFluent.PersistentVolumeListNested editPersistentVolumeList(){
            return withNewPersistentVolumeListLike(getPersistentVolumeList());
    }

    public KubeSchemaFluent.PersistentVolumeListNested editOrNewPersistentVolumeList(){
            return withNewPersistentVolumeListLike(getPersistentVolumeList() != null ? getPersistentVolumeList(): new PersistentVolumeListBuilder().build());
    }

    public KubeSchemaFluent.PersistentVolumeListNested editOrNewPersistentVolumeListLike(PersistentVolumeList item){
            return withNewPersistentVolumeListLike(getPersistentVolumeList() != null ? getPersistentVolumeList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPipeline instead.
 */
@Deprecated public Pipeline getPipeline(){
            return this.pipeline!=null?this.pipeline.build():null;
    }

    public Pipeline buildPipeline(){
            return this.pipeline!=null?this.pipeline.build():null;
    }

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

    public Boolean hasPipeline(){
            return this.pipeline!=null;
    }

    public KubeSchemaFluent.PipelineNested withNewPipeline(){
            return new PipelineNestedImpl();
    }

    public KubeSchemaFluent.PipelineNested withNewPipelineLike(Pipeline item){
            return new PipelineNestedImpl(item);
    }

    public KubeSchemaFluent.PipelineNested editPipeline(){
            return withNewPipelineLike(getPipeline());
    }

    public KubeSchemaFluent.PipelineNested editOrNewPipeline(){
            return withNewPipelineLike(getPipeline() != null ? getPipeline(): new PipelineBuilder().build());
    }

    public KubeSchemaFluent.PipelineNested editOrNewPipelineLike(Pipeline item){
            return withNewPipelineLike(getPipeline() != null ? getPipeline(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPipelineConfig instead.
 */
@Deprecated public PipelineConfig getPipelineConfig(){
            return this.pipelineConfig!=null?this.pipelineConfig.build():null;
    }

    public PipelineConfig buildPipelineConfig(){
            return this.pipelineConfig!=null?this.pipelineConfig.build():null;
    }

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

    public Boolean hasPipelineConfig(){
            return this.pipelineConfig!=null;
    }

    public KubeSchemaFluent.PipelineConfigNested withNewPipelineConfig(){
            return new PipelineConfigNestedImpl();
    }

    public KubeSchemaFluent.PipelineConfigNested withNewPipelineConfigLike(PipelineConfig item){
            return new PipelineConfigNestedImpl(item);
    }

    public KubeSchemaFluent.PipelineConfigNested editPipelineConfig(){
            return withNewPipelineConfigLike(getPipelineConfig());
    }

    public KubeSchemaFluent.PipelineConfigNested editOrNewPipelineConfig(){
            return withNewPipelineConfigLike(getPipelineConfig() != null ? getPipelineConfig(): new PipelineConfigBuilder().build());
    }

    public KubeSchemaFluent.PipelineConfigNested editOrNewPipelineConfigLike(PipelineConfig item){
            return withNewPipelineConfigLike(getPipelineConfig() != null ? getPipelineConfig(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPipelineConfigList instead.
 */
@Deprecated public PipelineConfigList getPipelineConfigList(){
            return this.pipelineConfigList!=null?this.pipelineConfigList.build():null;
    }

    public PipelineConfigList buildPipelineConfigList(){
            return this.pipelineConfigList!=null?this.pipelineConfigList.build():null;
    }

    public A withPipelineConfigList(PipelineConfigList pipelineConfigList){
            _visitables.remove(this.pipelineConfigList);
            if (pipelineConfigList!=null){ this.pipelineConfigList= new PipelineConfigListBuilder(pipelineConfigList); _visitables.add(this.pipelineConfigList);} return (A) this;
    }

    public Boolean hasPipelineConfigList(){
            return this.pipelineConfigList!=null;
    }

    public KubeSchemaFluent.PipelineConfigListNested withNewPipelineConfigList(){
            return new PipelineConfigListNestedImpl();
    }

    public KubeSchemaFluent.PipelineConfigListNested withNewPipelineConfigListLike(PipelineConfigList item){
            return new PipelineConfigListNestedImpl(item);
    }

    public KubeSchemaFluent.PipelineConfigListNested editPipelineConfigList(){
            return withNewPipelineConfigListLike(getPipelineConfigList());
    }

    public KubeSchemaFluent.PipelineConfigListNested editOrNewPipelineConfigList(){
            return withNewPipelineConfigListLike(getPipelineConfigList() != null ? getPipelineConfigList(): new PipelineConfigListBuilder().build());
    }

    public KubeSchemaFluent.PipelineConfigListNested editOrNewPipelineConfigListLike(PipelineConfigList item){
            return withNewPipelineConfigListLike(getPipelineConfigList() != null ? getPipelineConfigList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPipelineList instead.
 */
@Deprecated public PipelineList getPipelineList(){
            return this.pipelineList!=null?this.pipelineList.build():null;
    }

    public PipelineList buildPipelineList(){
            return this.pipelineList!=null?this.pipelineList.build():null;
    }

    public A withPipelineList(PipelineList pipelineList){
            _visitables.remove(this.pipelineList);
            if (pipelineList!=null){ this.pipelineList= new PipelineListBuilder(pipelineList); _visitables.add(this.pipelineList);} return (A) this;
    }

    public Boolean hasPipelineList(){
            return this.pipelineList!=null;
    }

    public KubeSchemaFluent.PipelineListNested withNewPipelineList(){
            return new PipelineListNestedImpl();
    }

    public KubeSchemaFluent.PipelineListNested withNewPipelineListLike(PipelineList item){
            return new PipelineListNestedImpl(item);
    }

    public KubeSchemaFluent.PipelineListNested editPipelineList(){
            return withNewPipelineListLike(getPipelineList());
    }

    public KubeSchemaFluent.PipelineListNested editOrNewPipelineList(){
            return withNewPipelineListLike(getPipelineList() != null ? getPipelineList(): new PipelineListBuilder().build());
    }

    public KubeSchemaFluent.PipelineListNested editOrNewPipelineListLike(PipelineList item){
            return withNewPipelineListLike(getPipelineList() != null ? getPipelineList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPodDisruptionBudget instead.
 */
@Deprecated public PodDisruptionBudget getPodDisruptionBudget(){
            return this.podDisruptionBudget!=null?this.podDisruptionBudget.build():null;
    }

    public PodDisruptionBudget buildPodDisruptionBudget(){
            return this.podDisruptionBudget!=null?this.podDisruptionBudget.build():null;
    }

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

    public Boolean hasPodDisruptionBudget(){
            return this.podDisruptionBudget!=null;
    }

    public KubeSchemaFluent.PodDisruptionBudgetNested withNewPodDisruptionBudget(){
            return new PodDisruptionBudgetNestedImpl();
    }

    public KubeSchemaFluent.PodDisruptionBudgetNested withNewPodDisruptionBudgetLike(PodDisruptionBudget item){
            return new PodDisruptionBudgetNestedImpl(item);
    }

    public KubeSchemaFluent.PodDisruptionBudgetNested editPodDisruptionBudget(){
            return withNewPodDisruptionBudgetLike(getPodDisruptionBudget());
    }

    public KubeSchemaFluent.PodDisruptionBudgetNested editOrNewPodDisruptionBudget(){
            return withNewPodDisruptionBudgetLike(getPodDisruptionBudget() != null ? getPodDisruptionBudget(): new PodDisruptionBudgetBuilder().build());
    }

    public KubeSchemaFluent.PodDisruptionBudgetNested editOrNewPodDisruptionBudgetLike(PodDisruptionBudget item){
            return withNewPodDisruptionBudgetLike(getPodDisruptionBudget() != null ? getPodDisruptionBudget(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPodDisruptionBudgetList instead.
 */
@Deprecated public PodDisruptionBudgetList getPodDisruptionBudgetList(){
            return this.podDisruptionBudgetList!=null?this.podDisruptionBudgetList.build():null;
    }

    public PodDisruptionBudgetList buildPodDisruptionBudgetList(){
            return this.podDisruptionBudgetList!=null?this.podDisruptionBudgetList.build():null;
    }

    public A withPodDisruptionBudgetList(PodDisruptionBudgetList podDisruptionBudgetList){
            _visitables.remove(this.podDisruptionBudgetList);
            if (podDisruptionBudgetList!=null){ this.podDisruptionBudgetList= new PodDisruptionBudgetListBuilder(podDisruptionBudgetList); _visitables.add(this.podDisruptionBudgetList);} return (A) this;
    }

    public Boolean hasPodDisruptionBudgetList(){
            return this.podDisruptionBudgetList!=null;
    }

    public KubeSchemaFluent.PodDisruptionBudgetListNested withNewPodDisruptionBudgetList(){
            return new PodDisruptionBudgetListNestedImpl();
    }

    public KubeSchemaFluent.PodDisruptionBudgetListNested withNewPodDisruptionBudgetListLike(PodDisruptionBudgetList item){
            return new PodDisruptionBudgetListNestedImpl(item);
    }

    public KubeSchemaFluent.PodDisruptionBudgetListNested editPodDisruptionBudgetList(){
            return withNewPodDisruptionBudgetListLike(getPodDisruptionBudgetList());
    }

    public KubeSchemaFluent.PodDisruptionBudgetListNested editOrNewPodDisruptionBudgetList(){
            return withNewPodDisruptionBudgetListLike(getPodDisruptionBudgetList() != null ? getPodDisruptionBudgetList(): new PodDisruptionBudgetListBuilder().build());
    }

    public KubeSchemaFluent.PodDisruptionBudgetListNested editOrNewPodDisruptionBudgetListLike(PodDisruptionBudgetList item){
            return withNewPodDisruptionBudgetListLike(getPodDisruptionBudgetList() != null ? getPodDisruptionBudgetList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPodList instead.
 */
@Deprecated public PodList getPodList(){
            return this.podList!=null?this.podList.build():null;
    }

    public PodList buildPodList(){
            return this.podList!=null?this.podList.build():null;
    }

    public A withPodList(PodList podList){
            _visitables.remove(this.podList);
            if (podList!=null){ this.podList= new PodListBuilder(podList); _visitables.add(this.podList);} return (A) this;
    }

    public Boolean hasPodList(){
            return this.podList!=null;
    }

    public KubeSchemaFluent.PodListNested withNewPodList(){
            return new PodListNestedImpl();
    }

    public KubeSchemaFluent.PodListNested withNewPodListLike(PodList item){
            return new PodListNestedImpl(item);
    }

    public KubeSchemaFluent.PodListNested editPodList(){
            return withNewPodListLike(getPodList());
    }

    public KubeSchemaFluent.PodListNested editOrNewPodList(){
            return withNewPodListLike(getPodList() != null ? getPodList(): new PodListBuilder().build());
    }

    public KubeSchemaFluent.PodListNested editOrNewPodListLike(PodList item){
            return withNewPodListLike(getPodList() != null ? getPodList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPodSecurityPolicy instead.
 */
@Deprecated public PodSecurityPolicy getPodSecurityPolicy(){
            return this.podSecurityPolicy!=null?this.podSecurityPolicy.build():null;
    }

    public PodSecurityPolicy buildPodSecurityPolicy(){
            return this.podSecurityPolicy!=null?this.podSecurityPolicy.build():null;
    }

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

    public Boolean hasPodSecurityPolicy(){
            return this.podSecurityPolicy!=null;
    }

    public KubeSchemaFluent.PodSecurityPolicyNested withNewPodSecurityPolicy(){
            return new PodSecurityPolicyNestedImpl();
    }

    public KubeSchemaFluent.PodSecurityPolicyNested withNewPodSecurityPolicyLike(PodSecurityPolicy item){
            return new PodSecurityPolicyNestedImpl(item);
    }

    public KubeSchemaFluent.PodSecurityPolicyNested editPodSecurityPolicy(){
            return withNewPodSecurityPolicyLike(getPodSecurityPolicy());
    }

    public KubeSchemaFluent.PodSecurityPolicyNested editOrNewPodSecurityPolicy(){
            return withNewPodSecurityPolicyLike(getPodSecurityPolicy() != null ? getPodSecurityPolicy(): new PodSecurityPolicyBuilder().build());
    }

    public KubeSchemaFluent.PodSecurityPolicyNested editOrNewPodSecurityPolicyLike(PodSecurityPolicy item){
            return withNewPodSecurityPolicyLike(getPodSecurityPolicy() != null ? getPodSecurityPolicy(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPodSecurityPolicyList instead.
 */
@Deprecated public PodSecurityPolicyList getPodSecurityPolicyList(){
            return this.podSecurityPolicyList!=null?this.podSecurityPolicyList.build():null;
    }

    public PodSecurityPolicyList buildPodSecurityPolicyList(){
            return this.podSecurityPolicyList!=null?this.podSecurityPolicyList.build():null;
    }

    public A withPodSecurityPolicyList(PodSecurityPolicyList podSecurityPolicyList){
            _visitables.remove(this.podSecurityPolicyList);
            if (podSecurityPolicyList!=null){ this.podSecurityPolicyList= new PodSecurityPolicyListBuilder(podSecurityPolicyList); _visitables.add(this.podSecurityPolicyList);} return (A) this;
    }

    public Boolean hasPodSecurityPolicyList(){
            return this.podSecurityPolicyList!=null;
    }

    public KubeSchemaFluent.PodSecurityPolicyListNested withNewPodSecurityPolicyList(){
            return new PodSecurityPolicyListNestedImpl();
    }

    public KubeSchemaFluent.PodSecurityPolicyListNested withNewPodSecurityPolicyListLike(PodSecurityPolicyList item){
            return new PodSecurityPolicyListNestedImpl(item);
    }

    public KubeSchemaFluent.PodSecurityPolicyListNested editPodSecurityPolicyList(){
            return withNewPodSecurityPolicyListLike(getPodSecurityPolicyList());
    }

    public KubeSchemaFluent.PodSecurityPolicyListNested editOrNewPodSecurityPolicyList(){
            return withNewPodSecurityPolicyListLike(getPodSecurityPolicyList() != null ? getPodSecurityPolicyList(): new PodSecurityPolicyListBuilder().build());
    }

    public KubeSchemaFluent.PodSecurityPolicyListNested editOrNewPodSecurityPolicyListLike(PodSecurityPolicyList item){
            return withNewPodSecurityPolicyListLike(getPodSecurityPolicyList() != null ? getPodSecurityPolicyList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPodTemplateList instead.
 */
@Deprecated public PodTemplateList getPodTemplateList(){
            return this.podTemplateList!=null?this.podTemplateList.build():null;
    }

    public PodTemplateList buildPodTemplateList(){
            return this.podTemplateList!=null?this.podTemplateList.build():null;
    }

    public A withPodTemplateList(PodTemplateList podTemplateList){
            _visitables.remove(this.podTemplateList);
            if (podTemplateList!=null){ this.podTemplateList= new PodTemplateListBuilder(podTemplateList); _visitables.add(this.podTemplateList);} return (A) this;
    }

    public Boolean hasPodTemplateList(){
            return this.podTemplateList!=null;
    }

    public KubeSchemaFluent.PodTemplateListNested withNewPodTemplateList(){
            return new PodTemplateListNestedImpl();
    }

    public KubeSchemaFluent.PodTemplateListNested withNewPodTemplateListLike(PodTemplateList item){
            return new PodTemplateListNestedImpl(item);
    }

    public KubeSchemaFluent.PodTemplateListNested editPodTemplateList(){
            return withNewPodTemplateListLike(getPodTemplateList());
    }

    public KubeSchemaFluent.PodTemplateListNested editOrNewPodTemplateList(){
            return withNewPodTemplateListLike(getPodTemplateList() != null ? getPodTemplateList(): new PodTemplateListBuilder().build());
    }

    public KubeSchemaFluent.PodTemplateListNested editOrNewPodTemplateListLike(PodTemplateList item){
            return withNewPodTemplateListLike(getPodTemplateList() != null ? getPodTemplateList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPolicy instead.
 */
@Deprecated public Policy getPolicy(){
            return this.policy!=null?this.policy.build():null;
    }

    public Policy buildPolicy(){
            return this.policy!=null?this.policy.build():null;
    }

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

    public Boolean hasPolicy(){
            return this.policy!=null;
    }

    public KubeSchemaFluent.PolicyNested withNewPolicy(){
            return new PolicyNestedImpl();
    }

    public KubeSchemaFluent.PolicyNested withNewPolicyLike(Policy item){
            return new PolicyNestedImpl(item);
    }

    public KubeSchemaFluent.PolicyNested editPolicy(){
            return withNewPolicyLike(getPolicy());
    }

    public KubeSchemaFluent.PolicyNested editOrNewPolicy(){
            return withNewPolicyLike(getPolicy() != null ? getPolicy(): new PolicyBuilder().build());
    }

    public KubeSchemaFluent.PolicyNested editOrNewPolicyLike(Policy item){
            return withNewPolicyLike(getPolicy() != null ? getPolicy(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPolicyBinding instead.
 */
@Deprecated public PolicyBinding getPolicyBinding(){
            return this.policyBinding!=null?this.policyBinding.build():null;
    }

    public PolicyBinding buildPolicyBinding(){
            return this.policyBinding!=null?this.policyBinding.build():null;
    }

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

    public Boolean hasPolicyBinding(){
            return this.policyBinding!=null;
    }

    public KubeSchemaFluent.PolicyBindingNested withNewPolicyBinding(){
            return new PolicyBindingNestedImpl();
    }

    public KubeSchemaFluent.PolicyBindingNested withNewPolicyBindingLike(PolicyBinding item){
            return new PolicyBindingNestedImpl(item);
    }

    public KubeSchemaFluent.PolicyBindingNested editPolicyBinding(){
            return withNewPolicyBindingLike(getPolicyBinding());
    }

    public KubeSchemaFluent.PolicyBindingNested editOrNewPolicyBinding(){
            return withNewPolicyBindingLike(getPolicyBinding() != null ? getPolicyBinding(): new PolicyBindingBuilder().build());
    }

    public KubeSchemaFluent.PolicyBindingNested editOrNewPolicyBindingLike(PolicyBinding item){
            return withNewPolicyBindingLike(getPolicyBinding() != null ? getPolicyBinding(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPolicyBindingList instead.
 */
@Deprecated public PolicyBindingList getPolicyBindingList(){
            return this.policyBindingList!=null?this.policyBindingList.build():null;
    }

    public PolicyBindingList buildPolicyBindingList(){
            return this.policyBindingList!=null?this.policyBindingList.build():null;
    }

    public A withPolicyBindingList(PolicyBindingList policyBindingList){
            _visitables.remove(this.policyBindingList);
            if (policyBindingList!=null){ this.policyBindingList= new PolicyBindingListBuilder(policyBindingList); _visitables.add(this.policyBindingList);} return (A) this;
    }

    public Boolean hasPolicyBindingList(){
            return this.policyBindingList!=null;
    }

    public KubeSchemaFluent.PolicyBindingListNested withNewPolicyBindingList(){
            return new PolicyBindingListNestedImpl();
    }

    public KubeSchemaFluent.PolicyBindingListNested withNewPolicyBindingListLike(PolicyBindingList item){
            return new PolicyBindingListNestedImpl(item);
    }

    public KubeSchemaFluent.PolicyBindingListNested editPolicyBindingList(){
            return withNewPolicyBindingListLike(getPolicyBindingList());
    }

    public KubeSchemaFluent.PolicyBindingListNested editOrNewPolicyBindingList(){
            return withNewPolicyBindingListLike(getPolicyBindingList() != null ? getPolicyBindingList(): new PolicyBindingListBuilder().build());
    }

    public KubeSchemaFluent.PolicyBindingListNested editOrNewPolicyBindingListLike(PolicyBindingList item){
            return withNewPolicyBindingListLike(getPolicyBindingList() != null ? getPolicyBindingList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildPolicyList instead.
 */
@Deprecated public PolicyList getPolicyList(){
            return this.policyList!=null?this.policyList.build():null;
    }

    public PolicyList buildPolicyList(){
            return this.policyList!=null?this.policyList.build():null;
    }

    public A withPolicyList(PolicyList policyList){
            _visitables.remove(this.policyList);
            if (policyList!=null){ this.policyList= new PolicyListBuilder(policyList); _visitables.add(this.policyList);} return (A) this;
    }

    public Boolean hasPolicyList(){
            return this.policyList!=null;
    }

    public KubeSchemaFluent.PolicyListNested withNewPolicyList(){
            return new PolicyListNestedImpl();
    }

    public KubeSchemaFluent.PolicyListNested withNewPolicyListLike(PolicyList item){
            return new PolicyListNestedImpl(item);
    }

    public KubeSchemaFluent.PolicyListNested editPolicyList(){
            return withNewPolicyListLike(getPolicyList());
    }

    public KubeSchemaFluent.PolicyListNested editOrNewPolicyList(){
            return withNewPolicyListLike(getPolicyList() != null ? getPolicyList(): new PolicyListBuilder().build());
    }

    public KubeSchemaFluent.PolicyListNested editOrNewPolicyListLike(PolicyList item){
            return withNewPolicyListLike(getPolicyList() != null ? getPolicyList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildProject instead.
 */
@Deprecated public Project getProject(){
            return this.project!=null?this.project.build():null;
    }

    public Project buildProject(){
            return this.project!=null?this.project.build():null;
    }

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

    public Boolean hasProject(){
            return this.project!=null;
    }

    public KubeSchemaFluent.ProjectNested withNewProject(){
            return new ProjectNestedImpl();
    }

    public KubeSchemaFluent.ProjectNested withNewProjectLike(Project item){
            return new ProjectNestedImpl(item);
    }

    public KubeSchemaFluent.ProjectNested editProject(){
            return withNewProjectLike(getProject());
    }

    public KubeSchemaFluent.ProjectNested editOrNewProject(){
            return withNewProjectLike(getProject() != null ? getProject(): new ProjectBuilder().build());
    }

    public KubeSchemaFluent.ProjectNested editOrNewProjectLike(Project item){
            return withNewProjectLike(getProject() != null ? getProject(): item);
    }

    
/**
 * This method has been deprecated, please use method buildProjectList instead.
 */
@Deprecated public ProjectList getProjectList(){
            return this.projectList!=null?this.projectList.build():null;
    }

    public ProjectList buildProjectList(){
            return this.projectList!=null?this.projectList.build():null;
    }

    public A withProjectList(ProjectList projectList){
            _visitables.remove(this.projectList);
            if (projectList!=null){ this.projectList= new ProjectListBuilder(projectList); _visitables.add(this.projectList);} return (A) this;
    }

    public Boolean hasProjectList(){
            return this.projectList!=null;
    }

    public KubeSchemaFluent.ProjectListNested withNewProjectList(){
            return new ProjectListNestedImpl();
    }

    public KubeSchemaFluent.ProjectListNested withNewProjectListLike(ProjectList item){
            return new ProjectListNestedImpl(item);
    }

    public KubeSchemaFluent.ProjectListNested editProjectList(){
            return withNewProjectListLike(getProjectList());
    }

    public KubeSchemaFluent.ProjectListNested editOrNewProjectList(){
            return withNewProjectListLike(getProjectList() != null ? getProjectList(): new ProjectListBuilder().build());
    }

    public KubeSchemaFluent.ProjectListNested editOrNewProjectListLike(ProjectList item){
            return withNewProjectListLike(getProjectList() != null ? getProjectList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildQuantity instead.
 */
@Deprecated public Quantity getQuantity(){
            return this.quantity!=null?this.quantity.build():null;
    }

    public Quantity buildQuantity(){
            return this.quantity!=null?this.quantity.build():null;
    }

    public A withQuantity(Quantity quantity){
            _visitables.remove(this.quantity);
            if (quantity!=null){ this.quantity= new QuantityBuilder(quantity); _visitables.add(this.quantity);} return (A) this;
    }

    public Boolean hasQuantity(){
            return this.quantity!=null;
    }

    public KubeSchemaFluent.QuantityNested withNewQuantity(){
            return new QuantityNestedImpl();
    }

    public KubeSchemaFluent.QuantityNested withNewQuantityLike(Quantity item){
            return new QuantityNestedImpl(item);
    }

    public KubeSchemaFluent.QuantityNested editQuantity(){
            return withNewQuantityLike(getQuantity());
    }

    public KubeSchemaFluent.QuantityNested editOrNewQuantity(){
            return withNewQuantityLike(getQuantity() != null ? getQuantity(): new QuantityBuilder().build());
    }

    public KubeSchemaFluent.QuantityNested editOrNewQuantityLike(Quantity item){
            return withNewQuantityLike(getQuantity() != null ? getQuantity(): item);
    }

    public A withNewQuantity(String amount){
            return (A)withQuantity(new Quantity(amount));
    }

    public A withNewQuantity(String amount,String format){
            return (A)withQuantity(new Quantity(amount, format));
    }

    
/**
 * This method has been deprecated, please use method buildReplicaSet instead.
 */
@Deprecated public ReplicaSet getReplicaSet(){
            return this.replicaSet!=null?this.replicaSet.build():null;
    }

    public ReplicaSet buildReplicaSet(){
            return this.replicaSet!=null?this.replicaSet.build():null;
    }

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

    public Boolean hasReplicaSet(){
            return this.replicaSet!=null;
    }

    public KubeSchemaFluent.ReplicaSetNested withNewReplicaSet(){
            return new ReplicaSetNestedImpl();
    }

    public KubeSchemaFluent.ReplicaSetNested withNewReplicaSetLike(ReplicaSet item){
            return new ReplicaSetNestedImpl(item);
    }

    public KubeSchemaFluent.ReplicaSetNested editReplicaSet(){
            return withNewReplicaSetLike(getReplicaSet());
    }

    public KubeSchemaFluent.ReplicaSetNested editOrNewReplicaSet(){
            return withNewReplicaSetLike(getReplicaSet() != null ? getReplicaSet(): new ReplicaSetBuilder().build());
    }

    public KubeSchemaFluent.ReplicaSetNested editOrNewReplicaSetLike(ReplicaSet item){
            return withNewReplicaSetLike(getReplicaSet() != null ? getReplicaSet(): item);
    }

    
/**
 * This method has been deprecated, please use method buildReplicaSetList instead.
 */
@Deprecated public ReplicaSetList getReplicaSetList(){
            return this.replicaSetList!=null?this.replicaSetList.build():null;
    }

    public ReplicaSetList buildReplicaSetList(){
            return this.replicaSetList!=null?this.replicaSetList.build():null;
    }

    public A withReplicaSetList(ReplicaSetList replicaSetList){
            _visitables.remove(this.replicaSetList);
            if (replicaSetList!=null){ this.replicaSetList= new ReplicaSetListBuilder(replicaSetList); _visitables.add(this.replicaSetList);} return (A) this;
    }

    public Boolean hasReplicaSetList(){
            return this.replicaSetList!=null;
    }

    public KubeSchemaFluent.ReplicaSetListNested withNewReplicaSetList(){
            return new ReplicaSetListNestedImpl();
    }

    public KubeSchemaFluent.ReplicaSetListNested withNewReplicaSetListLike(ReplicaSetList item){
            return new ReplicaSetListNestedImpl(item);
    }

    public KubeSchemaFluent.ReplicaSetListNested editReplicaSetList(){
            return withNewReplicaSetListLike(getReplicaSetList());
    }

    public KubeSchemaFluent.ReplicaSetListNested editOrNewReplicaSetList(){
            return withNewReplicaSetListLike(getReplicaSetList() != null ? getReplicaSetList(): new ReplicaSetListBuilder().build());
    }

    public KubeSchemaFluent.ReplicaSetListNested editOrNewReplicaSetListLike(ReplicaSetList item){
            return withNewReplicaSetListLike(getReplicaSetList() != null ? getReplicaSetList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildReplicationControllerList instead.
 */
@Deprecated public ReplicationControllerList getReplicationControllerList(){
            return this.replicationControllerList!=null?this.replicationControllerList.build():null;
    }

    public ReplicationControllerList buildReplicationControllerList(){
            return this.replicationControllerList!=null?this.replicationControllerList.build():null;
    }

    public A withReplicationControllerList(ReplicationControllerList replicationControllerList){
            _visitables.remove(this.replicationControllerList);
            if (replicationControllerList!=null){ this.replicationControllerList= new ReplicationControllerListBuilder(replicationControllerList); _visitables.add(this.replicationControllerList);} return (A) this;
    }

    public Boolean hasReplicationControllerList(){
            return this.replicationControllerList!=null;
    }

    public KubeSchemaFluent.ReplicationControllerListNested withNewReplicationControllerList(){
            return new ReplicationControllerListNestedImpl();
    }

    public KubeSchemaFluent.ReplicationControllerListNested withNewReplicationControllerListLike(ReplicationControllerList item){
            return new ReplicationControllerListNestedImpl(item);
    }

    public KubeSchemaFluent.ReplicationControllerListNested editReplicationControllerList(){
            return withNewReplicationControllerListLike(getReplicationControllerList());
    }

    public KubeSchemaFluent.ReplicationControllerListNested editOrNewReplicationControllerList(){
            return withNewReplicationControllerListLike(getReplicationControllerList() != null ? getReplicationControllerList(): new ReplicationControllerListBuilder().build());
    }

    public KubeSchemaFluent.ReplicationControllerListNested editOrNewReplicationControllerListLike(ReplicationControllerList item){
            return withNewReplicationControllerListLike(getReplicationControllerList() != null ? getReplicationControllerList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildResourceQuota instead.
 */
@Deprecated public ResourceQuota getResourceQuota(){
            return this.resourceQuota!=null?this.resourceQuota.build():null;
    }

    public ResourceQuota buildResourceQuota(){
            return this.resourceQuota!=null?this.resourceQuota.build():null;
    }

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

    public Boolean hasResourceQuota(){
            return this.resourceQuota!=null;
    }

    public KubeSchemaFluent.ResourceQuotaNested withNewResourceQuota(){
            return new ResourceQuotaNestedImpl();
    }

    public KubeSchemaFluent.ResourceQuotaNested withNewResourceQuotaLike(ResourceQuota item){
            return new ResourceQuotaNestedImpl(item);
    }

    public KubeSchemaFluent.ResourceQuotaNested editResourceQuota(){
            return withNewResourceQuotaLike(getResourceQuota());
    }

    public KubeSchemaFluent.ResourceQuotaNested editOrNewResourceQuota(){
            return withNewResourceQuotaLike(getResourceQuota() != null ? getResourceQuota(): new ResourceQuotaBuilder().build());
    }

    public KubeSchemaFluent.ResourceQuotaNested editOrNewResourceQuotaLike(ResourceQuota item){
            return withNewResourceQuotaLike(getResourceQuota() != null ? getResourceQuota(): item);
    }

    
/**
 * This method has been deprecated, please use method buildResourceQuotaList instead.
 */
@Deprecated public ResourceQuotaList getResourceQuotaList(){
            return this.resourceQuotaList!=null?this.resourceQuotaList.build():null;
    }

    public ResourceQuotaList buildResourceQuotaList(){
            return this.resourceQuotaList!=null?this.resourceQuotaList.build():null;
    }

    public A withResourceQuotaList(ResourceQuotaList resourceQuotaList){
            _visitables.remove(this.resourceQuotaList);
            if (resourceQuotaList!=null){ this.resourceQuotaList= new ResourceQuotaListBuilder(resourceQuotaList); _visitables.add(this.resourceQuotaList);} return (A) this;
    }

    public Boolean hasResourceQuotaList(){
            return this.resourceQuotaList!=null;
    }

    public KubeSchemaFluent.ResourceQuotaListNested withNewResourceQuotaList(){
            return new ResourceQuotaListNestedImpl();
    }

    public KubeSchemaFluent.ResourceQuotaListNested withNewResourceQuotaListLike(ResourceQuotaList item){
            return new ResourceQuotaListNestedImpl(item);
    }

    public KubeSchemaFluent.ResourceQuotaListNested editResourceQuotaList(){
            return withNewResourceQuotaListLike(getResourceQuotaList());
    }

    public KubeSchemaFluent.ResourceQuotaListNested editOrNewResourceQuotaList(){
            return withNewResourceQuotaListLike(getResourceQuotaList() != null ? getResourceQuotaList(): new ResourceQuotaListBuilder().build());
    }

    public KubeSchemaFluent.ResourceQuotaListNested editOrNewResourceQuotaListLike(ResourceQuotaList item){
            return withNewResourceQuotaListLike(getResourceQuotaList() != null ? getResourceQuotaList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRole instead.
 */
@Deprecated public Role getRole(){
            return this.role!=null?this.role.build():null;
    }

    public Role buildRole(){
            return this.role!=null?this.role.build():null;
    }

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

    public Boolean hasRole(){
            return this.role!=null;
    }

    public KubeSchemaFluent.RoleNested withNewRole(){
            return new RoleNestedImpl();
    }

    public KubeSchemaFluent.RoleNested withNewRoleLike(Role item){
            return new RoleNestedImpl(item);
    }

    public KubeSchemaFluent.RoleNested editRole(){
            return withNewRoleLike(getRole());
    }

    public KubeSchemaFluent.RoleNested editOrNewRole(){
            return withNewRoleLike(getRole() != null ? getRole(): new RoleBuilder().build());
    }

    public KubeSchemaFluent.RoleNested editOrNewRoleLike(Role item){
            return withNewRoleLike(getRole() != null ? getRole(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRoleBinding instead.
 */
@Deprecated public RoleBinding getRoleBinding(){
            return this.roleBinding!=null?this.roleBinding.build():null;
    }

    public RoleBinding buildRoleBinding(){
            return this.roleBinding!=null?this.roleBinding.build():null;
    }

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

    public Boolean hasRoleBinding(){
            return this.roleBinding!=null;
    }

    public KubeSchemaFluent.RoleBindingNested withNewRoleBinding(){
            return new RoleBindingNestedImpl();
    }

    public KubeSchemaFluent.RoleBindingNested withNewRoleBindingLike(RoleBinding item){
            return new RoleBindingNestedImpl(item);
    }

    public KubeSchemaFluent.RoleBindingNested editRoleBinding(){
            return withNewRoleBindingLike(getRoleBinding());
    }

    public KubeSchemaFluent.RoleBindingNested editOrNewRoleBinding(){
            return withNewRoleBindingLike(getRoleBinding() != null ? getRoleBinding(): new RoleBindingBuilder().build());
    }

    public KubeSchemaFluent.RoleBindingNested editOrNewRoleBindingLike(RoleBinding item){
            return withNewRoleBindingLike(getRoleBinding() != null ? getRoleBinding(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRoleBindingList instead.
 */
@Deprecated public RoleBindingList getRoleBindingList(){
            return this.roleBindingList!=null?this.roleBindingList.build():null;
    }

    public RoleBindingList buildRoleBindingList(){
            return this.roleBindingList!=null?this.roleBindingList.build():null;
    }

    public A withRoleBindingList(RoleBindingList roleBindingList){
            _visitables.remove(this.roleBindingList);
            if (roleBindingList!=null){ this.roleBindingList= new RoleBindingListBuilder(roleBindingList); _visitables.add(this.roleBindingList);} return (A) this;
    }

    public Boolean hasRoleBindingList(){
            return this.roleBindingList!=null;
    }

    public KubeSchemaFluent.RoleBindingListNested withNewRoleBindingList(){
            return new RoleBindingListNestedImpl();
    }

    public KubeSchemaFluent.RoleBindingListNested withNewRoleBindingListLike(RoleBindingList item){
            return new RoleBindingListNestedImpl(item);
    }

    public KubeSchemaFluent.RoleBindingListNested editRoleBindingList(){
            return withNewRoleBindingListLike(getRoleBindingList());
    }

    public KubeSchemaFluent.RoleBindingListNested editOrNewRoleBindingList(){
            return withNewRoleBindingListLike(getRoleBindingList() != null ? getRoleBindingList(): new RoleBindingListBuilder().build());
    }

    public KubeSchemaFluent.RoleBindingListNested editOrNewRoleBindingListLike(RoleBindingList item){
            return withNewRoleBindingListLike(getRoleBindingList() != null ? getRoleBindingList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRoleBindingRestriction instead.
 */
@Deprecated public RoleBindingRestriction getRoleBindingRestriction(){
            return this.roleBindingRestriction!=null?this.roleBindingRestriction.build():null;
    }

    public RoleBindingRestriction buildRoleBindingRestriction(){
            return this.roleBindingRestriction!=null?this.roleBindingRestriction.build():null;
    }

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

    public Boolean hasRoleBindingRestriction(){
            return this.roleBindingRestriction!=null;
    }

    public KubeSchemaFluent.RoleBindingRestrictionNested withNewRoleBindingRestriction(){
            return new RoleBindingRestrictionNestedImpl();
    }

    public KubeSchemaFluent.RoleBindingRestrictionNested withNewRoleBindingRestrictionLike(RoleBindingRestriction item){
            return new RoleBindingRestrictionNestedImpl(item);
    }

    public KubeSchemaFluent.RoleBindingRestrictionNested editRoleBindingRestriction(){
            return withNewRoleBindingRestrictionLike(getRoleBindingRestriction());
    }

    public KubeSchemaFluent.RoleBindingRestrictionNested editOrNewRoleBindingRestriction(){
            return withNewRoleBindingRestrictionLike(getRoleBindingRestriction() != null ? getRoleBindingRestriction(): new RoleBindingRestrictionBuilder().build());
    }

    public KubeSchemaFluent.RoleBindingRestrictionNested editOrNewRoleBindingRestrictionLike(RoleBindingRestriction item){
            return withNewRoleBindingRestrictionLike(getRoleBindingRestriction() != null ? getRoleBindingRestriction(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRoleList instead.
 */
@Deprecated public RoleList getRoleList(){
            return this.roleList!=null?this.roleList.build():null;
    }

    public RoleList buildRoleList(){
            return this.roleList!=null?this.roleList.build():null;
    }

    public A withRoleList(RoleList roleList){
            _visitables.remove(this.roleList);
            if (roleList!=null){ this.roleList= new RoleListBuilder(roleList); _visitables.add(this.roleList);} return (A) this;
    }

    public Boolean hasRoleList(){
            return this.roleList!=null;
    }

    public KubeSchemaFluent.RoleListNested withNewRoleList(){
            return new RoleListNestedImpl();
    }

    public KubeSchemaFluent.RoleListNested withNewRoleListLike(RoleList item){
            return new RoleListNestedImpl(item);
    }

    public KubeSchemaFluent.RoleListNested editRoleList(){
            return withNewRoleListLike(getRoleList());
    }

    public KubeSchemaFluent.RoleListNested editOrNewRoleList(){
            return withNewRoleListLike(getRoleList() != null ? getRoleList(): new RoleListBuilder().build());
    }

    public KubeSchemaFluent.RoleListNested editOrNewRoleListLike(RoleList item){
            return withNewRoleListLike(getRoleList() != null ? getRoleList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRootPaths instead.
 */
@Deprecated public RootPaths getRootPaths(){
            return this.rootPaths!=null?this.rootPaths.build():null;
    }

    public RootPaths buildRootPaths(){
            return this.rootPaths!=null?this.rootPaths.build():null;
    }

    public A withRootPaths(RootPaths rootPaths){
            _visitables.remove(this.rootPaths);
            if (rootPaths!=null){ this.rootPaths= new RootPathsBuilder(rootPaths); _visitables.add(this.rootPaths);} return (A) this;
    }

    public Boolean hasRootPaths(){
            return this.rootPaths!=null;
    }

    public KubeSchemaFluent.RootPathsNested withNewRootPaths(){
            return new RootPathsNestedImpl();
    }

    public KubeSchemaFluent.RootPathsNested withNewRootPathsLike(RootPaths item){
            return new RootPathsNestedImpl(item);
    }

    public KubeSchemaFluent.RootPathsNested editRootPaths(){
            return withNewRootPathsLike(getRootPaths());
    }

    public KubeSchemaFluent.RootPathsNested editOrNewRootPaths(){
            return withNewRootPathsLike(getRootPaths() != null ? getRootPaths(): new RootPathsBuilder().build());
    }

    public KubeSchemaFluent.RootPathsNested editOrNewRootPathsLike(RootPaths item){
            return withNewRootPathsLike(getRootPaths() != null ? getRootPaths(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRoute instead.
 */
@Deprecated public Route getRoute(){
            return this.route!=null?this.route.build():null;
    }

    public Route buildRoute(){
            return this.route!=null?this.route.build():null;
    }

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

    public Boolean hasRoute(){
            return this.route!=null;
    }

    public KubeSchemaFluent.RouteNested withNewRoute(){
            return new RouteNestedImpl();
    }

    public KubeSchemaFluent.RouteNested withNewRouteLike(Route item){
            return new RouteNestedImpl(item);
    }

    public KubeSchemaFluent.RouteNested editRoute(){
            return withNewRouteLike(getRoute());
    }

    public KubeSchemaFluent.RouteNested editOrNewRoute(){
            return withNewRouteLike(getRoute() != null ? getRoute(): new RouteBuilder().build());
    }

    public KubeSchemaFluent.RouteNested editOrNewRouteLike(Route item){
            return withNewRouteLike(getRoute() != null ? getRoute(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRouteList instead.
 */
@Deprecated public RouteList getRouteList(){
            return this.routeList!=null?this.routeList.build():null;
    }

    public RouteList buildRouteList(){
            return this.routeList!=null?this.routeList.build():null;
    }

    public A withRouteList(RouteList routeList){
            _visitables.remove(this.routeList);
            if (routeList!=null){ this.routeList= new RouteListBuilder(routeList); _visitables.add(this.routeList);} return (A) this;
    }

    public Boolean hasRouteList(){
            return this.routeList!=null;
    }

    public KubeSchemaFluent.RouteListNested withNewRouteList(){
            return new RouteListNestedImpl();
    }

    public KubeSchemaFluent.RouteListNested withNewRouteListLike(RouteList item){
            return new RouteListNestedImpl(item);
    }

    public KubeSchemaFluent.RouteListNested editRouteList(){
            return withNewRouteListLike(getRouteList());
    }

    public KubeSchemaFluent.RouteListNested editOrNewRouteList(){
            return withNewRouteListLike(getRouteList() != null ? getRouteList(): new RouteListBuilder().build());
    }

    public KubeSchemaFluent.RouteListNested editOrNewRouteListLike(RouteList item){
            return withNewRouteListLike(getRouteList() != null ? getRouteList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildScale instead.
 */
@Deprecated public Scale getScale(){
            return this.scale!=null?this.scale.build():null;
    }

    public Scale buildScale(){
            return this.scale!=null?this.scale.build():null;
    }

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

    public Boolean hasScale(){
            return this.scale!=null;
    }

    public KubeSchemaFluent.ScaleNested withNewScale(){
            return new ScaleNestedImpl();
    }

    public KubeSchemaFluent.ScaleNested withNewScaleLike(Scale item){
            return new ScaleNestedImpl(item);
    }

    public KubeSchemaFluent.ScaleNested editScale(){
            return withNewScaleLike(getScale());
    }

    public KubeSchemaFluent.ScaleNested editOrNewScale(){
            return withNewScaleLike(getScale() != null ? getScale(): new ScaleBuilder().build());
    }

    public KubeSchemaFluent.ScaleNested editOrNewScaleLike(Scale item){
            return withNewScaleLike(getScale() != null ? getScale(): item);
    }

    
/**
 * This method has been deprecated, please use method buildSecret instead.
 */
@Deprecated public Secret getSecret(){
            return this.secret!=null?this.secret.build():null;
    }

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

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

    public Boolean hasSecret(){
            return this.secret!=null;
    }

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

    public KubeSchemaFluent.SecretNested withNewSecretLike(Secret item){
            return new SecretNestedImpl(item);
    }

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

    public KubeSchemaFluent.SecretNested editOrNewSecret(){
            return withNewSecretLike(getSecret() != null ? getSecret(): new SecretBuilder().build());
    }

    public KubeSchemaFluent.SecretNested editOrNewSecretLike(Secret item){
            return withNewSecretLike(getSecret() != null ? getSecret(): item);
    }

    
/**
 * This method has been deprecated, please use method buildSecretList instead.
 */
@Deprecated public SecretList getSecretList(){
            return this.secretList!=null?this.secretList.build():null;
    }

    public SecretList buildSecretList(){
            return this.secretList!=null?this.secretList.build():null;
    }

    public A withSecretList(SecretList secretList){
            _visitables.remove(this.secretList);
            if (secretList!=null){ this.secretList= new SecretListBuilder(secretList); _visitables.add(this.secretList);} return (A) this;
    }

    public Boolean hasSecretList(){
            return this.secretList!=null;
    }

    public KubeSchemaFluent.SecretListNested withNewSecretList(){
            return new SecretListNestedImpl();
    }

    public KubeSchemaFluent.SecretListNested withNewSecretListLike(SecretList item){
            return new SecretListNestedImpl(item);
    }

    public KubeSchemaFluent.SecretListNested editSecretList(){
            return withNewSecretListLike(getSecretList());
    }

    public KubeSchemaFluent.SecretListNested editOrNewSecretList(){
            return withNewSecretListLike(getSecretList() != null ? getSecretList(): new SecretListBuilder().build());
    }

    public KubeSchemaFluent.SecretListNested editOrNewSecretListLike(SecretList item){
            return withNewSecretListLike(getSecretList() != null ? getSecretList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildSecurityContextConstraints instead.
 */
@Deprecated public SecurityContextConstraints getSecurityContextConstraints(){
            return this.securityContextConstraints!=null?this.securityContextConstraints.build():null;
    }

    public SecurityContextConstraints buildSecurityContextConstraints(){
            return this.securityContextConstraints!=null?this.securityContextConstraints.build():null;
    }

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

    public Boolean hasSecurityContextConstraints(){
            return this.securityContextConstraints!=null;
    }

    public KubeSchemaFluent.SecurityContextConstraintsNested withNewSecurityContextConstraints(){
            return new SecurityContextConstraintsNestedImpl();
    }

    public KubeSchemaFluent.SecurityContextConstraintsNested withNewSecurityContextConstraintsLike(SecurityContextConstraints item){
            return new SecurityContextConstraintsNestedImpl(item);
    }

    public KubeSchemaFluent.SecurityContextConstraintsNested editSecurityContextConstraints(){
            return withNewSecurityContextConstraintsLike(getSecurityContextConstraints());
    }

    public KubeSchemaFluent.SecurityContextConstraintsNested editOrNewSecurityContextConstraints(){
            return withNewSecurityContextConstraintsLike(getSecurityContextConstraints() != null ? getSecurityContextConstraints(): new SecurityContextConstraintsBuilder().build());
    }

    public KubeSchemaFluent.SecurityContextConstraintsNested editOrNewSecurityContextConstraintsLike(SecurityContextConstraints item){
            return withNewSecurityContextConstraintsLike(getSecurityContextConstraints() != null ? getSecurityContextConstraints(): item);
    }

    
/**
 * This method has been deprecated, please use method buildSecurityContextConstraintsList instead.
 */
@Deprecated public SecurityContextConstraintsList getSecurityContextConstraintsList(){
            return this.securityContextConstraintsList!=null?this.securityContextConstraintsList.build():null;
    }

    public SecurityContextConstraintsList buildSecurityContextConstraintsList(){
            return this.securityContextConstraintsList!=null?this.securityContextConstraintsList.build():null;
    }

    public A withSecurityContextConstraintsList(SecurityContextConstraintsList securityContextConstraintsList){
            _visitables.remove(this.securityContextConstraintsList);
            if (securityContextConstraintsList!=null){ this.securityContextConstraintsList= new SecurityContextConstraintsListBuilder(securityContextConstraintsList); _visitables.add(this.securityContextConstraintsList);} return (A) this;
    }

    public Boolean hasSecurityContextConstraintsList(){
            return this.securityContextConstraintsList!=null;
    }

    public KubeSchemaFluent.SecurityContextConstraintsListNested withNewSecurityContextConstraintsList(){
            return new SecurityContextConstraintsListNestedImpl();
    }

    public KubeSchemaFluent.SecurityContextConstraintsListNested withNewSecurityContextConstraintsListLike(SecurityContextConstraintsList item){
            return new SecurityContextConstraintsListNestedImpl(item);
    }

    public KubeSchemaFluent.SecurityContextConstraintsListNested editSecurityContextConstraintsList(){
            return withNewSecurityContextConstraintsListLike(getSecurityContextConstraintsList());
    }

    public KubeSchemaFluent.SecurityContextConstraintsListNested editOrNewSecurityContextConstraintsList(){
            return withNewSecurityContextConstraintsListLike(getSecurityContextConstraintsList() != null ? getSecurityContextConstraintsList(): new SecurityContextConstraintsListBuilder().build());
    }

    public KubeSchemaFluent.SecurityContextConstraintsListNested editOrNewSecurityContextConstraintsListLike(SecurityContextConstraintsList item){
            return withNewSecurityContextConstraintsListLike(getSecurityContextConstraintsList() != null ? getSecurityContextConstraintsList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildServiceAccount instead.
 */
@Deprecated public ServiceAccount getServiceAccount(){
            return this.serviceAccount!=null?this.serviceAccount.build():null;
    }

    public ServiceAccount buildServiceAccount(){
            return this.serviceAccount!=null?this.serviceAccount.build():null;
    }

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

    public Boolean hasServiceAccount(){
            return this.serviceAccount!=null;
    }

    public KubeSchemaFluent.ServiceAccountNested withNewServiceAccount(){
            return new ServiceAccountNestedImpl();
    }

    public KubeSchemaFluent.ServiceAccountNested withNewServiceAccountLike(ServiceAccount item){
            return new ServiceAccountNestedImpl(item);
    }

    public KubeSchemaFluent.ServiceAccountNested editServiceAccount(){
            return withNewServiceAccountLike(getServiceAccount());
    }

    public KubeSchemaFluent.ServiceAccountNested editOrNewServiceAccount(){
            return withNewServiceAccountLike(getServiceAccount() != null ? getServiceAccount(): new ServiceAccountBuilder().build());
    }

    public KubeSchemaFluent.ServiceAccountNested editOrNewServiceAccountLike(ServiceAccount item){
            return withNewServiceAccountLike(getServiceAccount() != null ? getServiceAccount(): item);
    }

    
/**
 * This method has been deprecated, please use method buildServiceAccountList instead.
 */
@Deprecated public ServiceAccountList getServiceAccountList(){
            return this.serviceAccountList!=null?this.serviceAccountList.build():null;
    }

    public ServiceAccountList buildServiceAccountList(){
            return this.serviceAccountList!=null?this.serviceAccountList.build():null;
    }

    public A withServiceAccountList(ServiceAccountList serviceAccountList){
            _visitables.remove(this.serviceAccountList);
            if (serviceAccountList!=null){ this.serviceAccountList= new ServiceAccountListBuilder(serviceAccountList); _visitables.add(this.serviceAccountList);} return (A) this;
    }

    public Boolean hasServiceAccountList(){
            return this.serviceAccountList!=null;
    }

    public KubeSchemaFluent.ServiceAccountListNested withNewServiceAccountList(){
            return new ServiceAccountListNestedImpl();
    }

    public KubeSchemaFluent.ServiceAccountListNested withNewServiceAccountListLike(ServiceAccountList item){
            return new ServiceAccountListNestedImpl(item);
    }

    public KubeSchemaFluent.ServiceAccountListNested editServiceAccountList(){
            return withNewServiceAccountListLike(getServiceAccountList());
    }

    public KubeSchemaFluent.ServiceAccountListNested editOrNewServiceAccountList(){
            return withNewServiceAccountListLike(getServiceAccountList() != null ? getServiceAccountList(): new ServiceAccountListBuilder().build());
    }

    public KubeSchemaFluent.ServiceAccountListNested editOrNewServiceAccountListLike(ServiceAccountList item){
            return withNewServiceAccountListLike(getServiceAccountList() != null ? getServiceAccountList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildServiceList instead.
 */
@Deprecated public ServiceList getServiceList(){
            return this.serviceList!=null?this.serviceList.build():null;
    }

    public ServiceList buildServiceList(){
            return this.serviceList!=null?this.serviceList.build():null;
    }

    public A withServiceList(ServiceList serviceList){
            _visitables.remove(this.serviceList);
            if (serviceList!=null){ this.serviceList= new ServiceListBuilder(serviceList); _visitables.add(this.serviceList);} return (A) this;
    }

    public Boolean hasServiceList(){
            return this.serviceList!=null;
    }

    public KubeSchemaFluent.ServiceListNested withNewServiceList(){
            return new ServiceListNestedImpl();
    }

    public KubeSchemaFluent.ServiceListNested withNewServiceListLike(ServiceList item){
            return new ServiceListNestedImpl(item);
    }

    public KubeSchemaFluent.ServiceListNested editServiceList(){
            return withNewServiceListLike(getServiceList());
    }

    public KubeSchemaFluent.ServiceListNested editOrNewServiceList(){
            return withNewServiceListLike(getServiceList() != null ? getServiceList(): new ServiceListBuilder().build());
    }

    public KubeSchemaFluent.ServiceListNested editOrNewServiceListLike(ServiceList item){
            return withNewServiceListLike(getServiceList() != null ? getServiceList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildStatefulSet instead.
 */
@Deprecated public StatefulSet getStatefulSet(){
            return this.statefulSet!=null?this.statefulSet.build():null;
    }

    public StatefulSet buildStatefulSet(){
            return this.statefulSet!=null?this.statefulSet.build():null;
    }

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

    public Boolean hasStatefulSet(){
            return this.statefulSet!=null;
    }

    public KubeSchemaFluent.StatefulSetNested withNewStatefulSet(){
            return new StatefulSetNestedImpl();
    }

    public KubeSchemaFluent.StatefulSetNested withNewStatefulSetLike(StatefulSet item){
            return new StatefulSetNestedImpl(item);
    }

    public KubeSchemaFluent.StatefulSetNested editStatefulSet(){
            return withNewStatefulSetLike(getStatefulSet());
    }

    public KubeSchemaFluent.StatefulSetNested editOrNewStatefulSet(){
            return withNewStatefulSetLike(getStatefulSet() != null ? getStatefulSet(): new StatefulSetBuilder().build());
    }

    public KubeSchemaFluent.StatefulSetNested editOrNewStatefulSetLike(StatefulSet item){
            return withNewStatefulSetLike(getStatefulSet() != null ? getStatefulSet(): item);
    }

    
/**
 * This method has been deprecated, please use method buildStatefulSetList instead.
 */
@Deprecated public StatefulSetList getStatefulSetList(){
            return this.statefulSetList!=null?this.statefulSetList.build():null;
    }

    public StatefulSetList buildStatefulSetList(){
            return this.statefulSetList!=null?this.statefulSetList.build():null;
    }

    public A withStatefulSetList(StatefulSetList statefulSetList){
            _visitables.remove(this.statefulSetList);
            if (statefulSetList!=null){ this.statefulSetList= new StatefulSetListBuilder(statefulSetList); _visitables.add(this.statefulSetList);} return (A) this;
    }

    public Boolean hasStatefulSetList(){
            return this.statefulSetList!=null;
    }

    public KubeSchemaFluent.StatefulSetListNested withNewStatefulSetList(){
            return new StatefulSetListNestedImpl();
    }

    public KubeSchemaFluent.StatefulSetListNested withNewStatefulSetListLike(StatefulSetList item){
            return new StatefulSetListNestedImpl(item);
    }

    public KubeSchemaFluent.StatefulSetListNested editStatefulSetList(){
            return withNewStatefulSetListLike(getStatefulSetList());
    }

    public KubeSchemaFluent.StatefulSetListNested editOrNewStatefulSetList(){
            return withNewStatefulSetListLike(getStatefulSetList() != null ? getStatefulSetList(): new StatefulSetListBuilder().build());
    }

    public KubeSchemaFluent.StatefulSetListNested editOrNewStatefulSetListLike(StatefulSetList item){
            return withNewStatefulSetListLike(getStatefulSetList() != null ? getStatefulSetList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildStatus instead.
 */
@Deprecated public Status getStatus(){
            return this.status!=null?this.status.build():null;
    }

    public Status buildStatus(){
            return this.status!=null?this.status.build():null;
    }

    public A withStatus(Status status){
            _visitables.remove(this.status);
            if (status!=null){ this.status= new StatusBuilder(status); _visitables.add(this.status);} return (A) this;
    }

    public Boolean hasStatus(){
            return this.status!=null;
    }

    public KubeSchemaFluent.StatusNested withNewStatus(){
            return new StatusNestedImpl();
    }

    public KubeSchemaFluent.StatusNested withNewStatusLike(Status item){
            return new StatusNestedImpl(item);
    }

    public KubeSchemaFluent.StatusNested editStatus(){
            return withNewStatusLike(getStatus());
    }

    public KubeSchemaFluent.StatusNested editOrNewStatus(){
            return withNewStatusLike(getStatus() != null ? getStatus(): new StatusBuilder().build());
    }

    public KubeSchemaFluent.StatusNested editOrNewStatusLike(Status item){
            return withNewStatusLike(getStatus() != null ? getStatus(): item);
    }

    
/**
 * This method has been deprecated, please use method buildStorageClass instead.
 */
@Deprecated public StorageClass getStorageClass(){
            return this.storageClass!=null?this.storageClass.build():null;
    }

    public StorageClass buildStorageClass(){
            return this.storageClass!=null?this.storageClass.build():null;
    }

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

    public Boolean hasStorageClass(){
            return this.storageClass!=null;
    }

    public KubeSchemaFluent.StorageClassNested withNewStorageClass(){
            return new StorageClassNestedImpl();
    }

    public KubeSchemaFluent.StorageClassNested withNewStorageClassLike(StorageClass item){
            return new StorageClassNestedImpl(item);
    }

    public KubeSchemaFluent.StorageClassNested editStorageClass(){
            return withNewStorageClassLike(getStorageClass());
    }

    public KubeSchemaFluent.StorageClassNested editOrNewStorageClass(){
            return withNewStorageClassLike(getStorageClass() != null ? getStorageClass(): new StorageClassBuilder().build());
    }

    public KubeSchemaFluent.StorageClassNested editOrNewStorageClassLike(StorageClass item){
            return withNewStorageClassLike(getStorageClass() != null ? getStorageClass(): item);
    }

    
/**
 * This method has been deprecated, please use method buildStorageClassList instead.
 */
@Deprecated public StorageClassList getStorageClassList(){
            return this.storageClassList!=null?this.storageClassList.build():null;
    }

    public StorageClassList buildStorageClassList(){
            return this.storageClassList!=null?this.storageClassList.build():null;
    }

    public A withStorageClassList(StorageClassList storageClassList){
            _visitables.remove(this.storageClassList);
            if (storageClassList!=null){ this.storageClassList= new StorageClassListBuilder(storageClassList); _visitables.add(this.storageClassList);} return (A) this;
    }

    public Boolean hasStorageClassList(){
            return this.storageClassList!=null;
    }

    public KubeSchemaFluent.StorageClassListNested withNewStorageClassList(){
            return new StorageClassListNestedImpl();
    }

    public KubeSchemaFluent.StorageClassListNested withNewStorageClassListLike(StorageClassList item){
            return new StorageClassListNestedImpl(item);
    }

    public KubeSchemaFluent.StorageClassListNested editStorageClassList(){
            return withNewStorageClassListLike(getStorageClassList());
    }

    public KubeSchemaFluent.StorageClassListNested editOrNewStorageClassList(){
            return withNewStorageClassListLike(getStorageClassList() != null ? getStorageClassList(): new StorageClassListBuilder().build());
    }

    public KubeSchemaFluent.StorageClassListNested editOrNewStorageClassListLike(StorageClassList item){
            return withNewStorageClassListLike(getStorageClassList() != null ? getStorageClassList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildSubjectAccessReview instead.
 */
@Deprecated public SubjectAccessReview getSubjectAccessReview(){
            return this.subjectAccessReview!=null?this.subjectAccessReview.build():null;
    }

    public SubjectAccessReview buildSubjectAccessReview(){
            return this.subjectAccessReview!=null?this.subjectAccessReview.build():null;
    }

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

    public Boolean hasSubjectAccessReview(){
            return this.subjectAccessReview!=null;
    }

    public KubeSchemaFluent.SubjectAccessReviewNested withNewSubjectAccessReview(){
            return new SubjectAccessReviewNestedImpl();
    }

    public KubeSchemaFluent.SubjectAccessReviewNested withNewSubjectAccessReviewLike(SubjectAccessReview item){
            return new SubjectAccessReviewNestedImpl(item);
    }

    public KubeSchemaFluent.SubjectAccessReviewNested editSubjectAccessReview(){
            return withNewSubjectAccessReviewLike(getSubjectAccessReview());
    }

    public KubeSchemaFluent.SubjectAccessReviewNested editOrNewSubjectAccessReview(){
            return withNewSubjectAccessReviewLike(getSubjectAccessReview() != null ? getSubjectAccessReview(): new SubjectAccessReviewBuilder().build());
    }

    public KubeSchemaFluent.SubjectAccessReviewNested editOrNewSubjectAccessReviewLike(SubjectAccessReview item){
            return withNewSubjectAccessReviewLike(getSubjectAccessReview() != null ? getSubjectAccessReview(): item);
    }

    
/**
 * This method has been deprecated, please use method buildSubjectAccessReviewResponse instead.
 */
@Deprecated public SubjectAccessReviewResponse getSubjectAccessReviewResponse(){
            return this.subjectAccessReviewResponse!=null?this.subjectAccessReviewResponse.build():null;
    }

    public SubjectAccessReviewResponse buildSubjectAccessReviewResponse(){
            return this.subjectAccessReviewResponse!=null?this.subjectAccessReviewResponse.build():null;
    }

    public A withSubjectAccessReviewResponse(SubjectAccessReviewResponse subjectAccessReviewResponse){
            _visitables.remove(this.subjectAccessReviewResponse);
            if (subjectAccessReviewResponse!=null){ this.subjectAccessReviewResponse= new SubjectAccessReviewResponseBuilder(subjectAccessReviewResponse); _visitables.add(this.subjectAccessReviewResponse);} return (A) this;
    }

    public Boolean hasSubjectAccessReviewResponse(){
            return this.subjectAccessReviewResponse!=null;
    }

    public KubeSchemaFluent.SubjectAccessReviewResponseNested withNewSubjectAccessReviewResponse(){
            return new SubjectAccessReviewResponseNestedImpl();
    }

    public KubeSchemaFluent.SubjectAccessReviewResponseNested withNewSubjectAccessReviewResponseLike(SubjectAccessReviewResponse item){
            return new SubjectAccessReviewResponseNestedImpl(item);
    }

    public KubeSchemaFluent.SubjectAccessReviewResponseNested editSubjectAccessReviewResponse(){
            return withNewSubjectAccessReviewResponseLike(getSubjectAccessReviewResponse());
    }

    public KubeSchemaFluent.SubjectAccessReviewResponseNested editOrNewSubjectAccessReviewResponse(){
            return withNewSubjectAccessReviewResponseLike(getSubjectAccessReviewResponse() != null ? getSubjectAccessReviewResponse(): new SubjectAccessReviewResponseBuilder().build());
    }

    public KubeSchemaFluent.SubjectAccessReviewResponseNested editOrNewSubjectAccessReviewResponseLike(SubjectAccessReviewResponse item){
            return withNewSubjectAccessReviewResponseLike(getSubjectAccessReviewResponse() != null ? getSubjectAccessReviewResponse(): item);
    }

    
/**
 * This method has been deprecated, please use method buildTagEvent instead.
 */
@Deprecated public TagEvent getTagEvent(){
            return this.tagEvent!=null?this.tagEvent.build():null;
    }

    public TagEvent buildTagEvent(){
            return this.tagEvent!=null?this.tagEvent.build():null;
    }

    public A withTagEvent(TagEvent tagEvent){
            _visitables.remove(this.tagEvent);
            if (tagEvent!=null){ this.tagEvent= new TagEventBuilder(tagEvent); _visitables.add(this.tagEvent);} return (A) this;
    }

    public Boolean hasTagEvent(){
            return this.tagEvent!=null;
    }

    public KubeSchemaFluent.TagEventNested withNewTagEvent(){
            return new TagEventNestedImpl();
    }

    public KubeSchemaFluent.TagEventNested withNewTagEventLike(TagEvent item){
            return new TagEventNestedImpl(item);
    }

    public KubeSchemaFluent.TagEventNested editTagEvent(){
            return withNewTagEventLike(getTagEvent());
    }

    public KubeSchemaFluent.TagEventNested editOrNewTagEvent(){
            return withNewTagEventLike(getTagEvent() != null ? getTagEvent(): new TagEventBuilder().build());
    }

    public KubeSchemaFluent.TagEventNested editOrNewTagEventLike(TagEvent item){
            return withNewTagEventLike(getTagEvent() != null ? getTagEvent(): item);
    }

    public A withNewTagEvent(String created,String dockerImageReference,Long generation,String image){
            return (A)withTagEvent(new TagEvent(created, dockerImageReference, generation, image));
    }

    
/**
 * This method has been deprecated, please use method buildTemplate instead.
 */
@Deprecated public Template getTemplate(){
            return this.template!=null?this.template.build():null;
    }

    public Template buildTemplate(){
            return this.template!=null?this.template.build():null;
    }

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

    public Boolean hasTemplate(){
            return this.template!=null;
    }

    public KubeSchemaFluent.TemplateNested withNewTemplate(){
            return new TemplateNestedImpl();
    }

    public KubeSchemaFluent.TemplateNested withNewTemplateLike(Template item){
            return new TemplateNestedImpl(item);
    }

    public KubeSchemaFluent.TemplateNested editTemplate(){
            return withNewTemplateLike(getTemplate());
    }

    public KubeSchemaFluent.TemplateNested editOrNewTemplate(){
            return withNewTemplateLike(getTemplate() != null ? getTemplate(): new TemplateBuilder().build());
    }

    public KubeSchemaFluent.TemplateNested editOrNewTemplateLike(Template item){
            return withNewTemplateLike(getTemplate() != null ? getTemplate(): item);
    }

    
/**
 * This method has been deprecated, please use method buildTemplateList instead.
 */
@Deprecated public TemplateList getTemplateList(){
            return this.templateList!=null?this.templateList.build():null;
    }

    public TemplateList buildTemplateList(){
            return this.templateList!=null?this.templateList.build():null;
    }

    public A withTemplateList(TemplateList templateList){
            _visitables.remove(this.templateList);
            if (templateList!=null){ this.templateList= new TemplateListBuilder(templateList); _visitables.add(this.templateList);} return (A) this;
    }

    public Boolean hasTemplateList(){
            return this.templateList!=null;
    }

    public KubeSchemaFluent.TemplateListNested withNewTemplateList(){
            return new TemplateListNestedImpl();
    }

    public KubeSchemaFluent.TemplateListNested withNewTemplateListLike(TemplateList item){
            return new TemplateListNestedImpl(item);
    }

    public KubeSchemaFluent.TemplateListNested editTemplateList(){
            return withNewTemplateListLike(getTemplateList());
    }

    public KubeSchemaFluent.TemplateListNested editOrNewTemplateList(){
            return withNewTemplateListLike(getTemplateList() != null ? getTemplateList(): new TemplateListBuilder().build());
    }

    public KubeSchemaFluent.TemplateListNested editOrNewTemplateListLike(TemplateList item){
            return withNewTemplateListLike(getTemplateList() != null ? getTemplateList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildThirdPartyResource instead.
 */
@Deprecated public ThirdPartyResource getThirdPartyResource(){
            return this.thirdPartyResource!=null?this.thirdPartyResource.build():null;
    }

    public ThirdPartyResource buildThirdPartyResource(){
            return this.thirdPartyResource!=null?this.thirdPartyResource.build():null;
    }

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

    public Boolean hasThirdPartyResource(){
            return this.thirdPartyResource!=null;
    }

    public KubeSchemaFluent.ThirdPartyResourceNested withNewThirdPartyResource(){
            return new ThirdPartyResourceNestedImpl();
    }

    public KubeSchemaFluent.ThirdPartyResourceNested withNewThirdPartyResourceLike(ThirdPartyResource item){
            return new ThirdPartyResourceNestedImpl(item);
    }

    public KubeSchemaFluent.ThirdPartyResourceNested editThirdPartyResource(){
            return withNewThirdPartyResourceLike(getThirdPartyResource());
    }

    public KubeSchemaFluent.ThirdPartyResourceNested editOrNewThirdPartyResource(){
            return withNewThirdPartyResourceLike(getThirdPartyResource() != null ? getThirdPartyResource(): new ThirdPartyResourceBuilder().build());
    }

    public KubeSchemaFluent.ThirdPartyResourceNested editOrNewThirdPartyResourceLike(ThirdPartyResource item){
            return withNewThirdPartyResourceLike(getThirdPartyResource() != null ? getThirdPartyResource(): item);
    }

    
/**
 * This method has been deprecated, please use method buildThirdPartyResourceList instead.
 */
@Deprecated public ThirdPartyResourceList getThirdPartyResourceList(){
            return this.thirdPartyResourceList!=null?this.thirdPartyResourceList.build():null;
    }

    public ThirdPartyResourceList buildThirdPartyResourceList(){
            return this.thirdPartyResourceList!=null?this.thirdPartyResourceList.build():null;
    }

    public A withThirdPartyResourceList(ThirdPartyResourceList thirdPartyResourceList){
            _visitables.remove(this.thirdPartyResourceList);
            if (thirdPartyResourceList!=null){ this.thirdPartyResourceList= new ThirdPartyResourceListBuilder(thirdPartyResourceList); _visitables.add(this.thirdPartyResourceList);} return (A) this;
    }

    public Boolean hasThirdPartyResourceList(){
            return this.thirdPartyResourceList!=null;
    }

    public KubeSchemaFluent.ThirdPartyResourceListNested withNewThirdPartyResourceList(){
            return new ThirdPartyResourceListNestedImpl();
    }

    public KubeSchemaFluent.ThirdPartyResourceListNested withNewThirdPartyResourceListLike(ThirdPartyResourceList item){
            return new ThirdPartyResourceListNestedImpl(item);
    }

    public KubeSchemaFluent.ThirdPartyResourceListNested editThirdPartyResourceList(){
            return withNewThirdPartyResourceListLike(getThirdPartyResourceList());
    }

    public KubeSchemaFluent.ThirdPartyResourceListNested editOrNewThirdPartyResourceList(){
            return withNewThirdPartyResourceListLike(getThirdPartyResourceList() != null ? getThirdPartyResourceList(): new ThirdPartyResourceListBuilder().build());
    }

    public KubeSchemaFluent.ThirdPartyResourceListNested editOrNewThirdPartyResourceListLike(ThirdPartyResourceList item){
            return withNewThirdPartyResourceListLike(getThirdPartyResourceList() != null ? getThirdPartyResourceList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildTokenReview instead.
 */
@Deprecated public TokenReview getTokenReview(){
            return this.tokenReview!=null?this.tokenReview.build():null;
    }

    public TokenReview buildTokenReview(){
            return this.tokenReview!=null?this.tokenReview.build():null;
    }

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

    public Boolean hasTokenReview(){
            return this.tokenReview!=null;
    }

    public KubeSchemaFluent.TokenReviewNested withNewTokenReview(){
            return new TokenReviewNestedImpl();
    }

    public KubeSchemaFluent.TokenReviewNested withNewTokenReviewLike(TokenReview item){
            return new TokenReviewNestedImpl(item);
    }

    public KubeSchemaFluent.TokenReviewNested editTokenReview(){
            return withNewTokenReviewLike(getTokenReview());
    }

    public KubeSchemaFluent.TokenReviewNested editOrNewTokenReview(){
            return withNewTokenReviewLike(getTokenReview() != null ? getTokenReview(): new TokenReviewBuilder().build());
    }

    public KubeSchemaFluent.TokenReviewNested editOrNewTokenReviewLike(TokenReview item){
            return withNewTokenReviewLike(getTokenReview() != null ? getTokenReview(): item);
    }

    
/**
 * This method has been deprecated, please use method buildToleration instead.
 */
@Deprecated public Toleration getToleration(){
            return this.toleration!=null?this.toleration.build():null;
    }

    public Toleration buildToleration(){
            return this.toleration!=null?this.toleration.build():null;
    }

    public A withToleration(Toleration toleration){
            _visitables.remove(this.toleration);
            if (toleration!=null){ this.toleration= new TolerationBuilder(toleration); _visitables.add(this.toleration);} return (A) this;
    }

    public Boolean hasToleration(){
            return this.toleration!=null;
    }

    public KubeSchemaFluent.TolerationNested withNewToleration(){
            return new TolerationNestedImpl();
    }

    public KubeSchemaFluent.TolerationNested withNewTolerationLike(Toleration item){
            return new TolerationNestedImpl(item);
    }

    public KubeSchemaFluent.TolerationNested editToleration(){
            return withNewTolerationLike(getToleration());
    }

    public KubeSchemaFluent.TolerationNested editOrNewToleration(){
            return withNewTolerationLike(getToleration() != null ? getToleration(): new TolerationBuilder().build());
    }

    public KubeSchemaFluent.TolerationNested editOrNewTolerationLike(Toleration item){
            return withNewTolerationLike(getToleration() != null ? getToleration(): item);
    }

    public A withNewToleration(String effect,String key,String operator,Long tolerationSeconds,String value){
            return (A)withToleration(new Toleration(effect, key, operator, tolerationSeconds, value));
    }

    
/**
 * This method has been deprecated, please use method buildUser instead.
 */
@Deprecated public User getUser(){
            return this.user!=null?this.user.build():null;
    }

    public User buildUser(){
            return this.user!=null?this.user.build():null;
    }

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

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

    public KubeSchemaFluent.UserNested withNewUser(){
            return new UserNestedImpl();
    }

    public KubeSchemaFluent.UserNested withNewUserLike(User item){
            return new UserNestedImpl(item);
    }

    public KubeSchemaFluent.UserNested editUser(){
            return withNewUserLike(getUser());
    }

    public KubeSchemaFluent.UserNested editOrNewUser(){
            return withNewUserLike(getUser() != null ? getUser(): new UserBuilder().build());
    }

    public KubeSchemaFluent.UserNested editOrNewUserLike(User item){
            return withNewUserLike(getUser() != null ? getUser(): item);
    }

    
/**
 * This method has been deprecated, please use method buildUserList instead.
 */
@Deprecated public UserList getUserList(){
            return this.userList!=null?this.userList.build():null;
    }

    public UserList buildUserList(){
            return this.userList!=null?this.userList.build():null;
    }

    public A withUserList(UserList userList){
            _visitables.remove(this.userList);
            if (userList!=null){ this.userList= new UserListBuilder(userList); _visitables.add(this.userList);} return (A) this;
    }

    public Boolean hasUserList(){
            return this.userList!=null;
    }

    public KubeSchemaFluent.UserListNested withNewUserList(){
            return new UserListNestedImpl();
    }

    public KubeSchemaFluent.UserListNested withNewUserListLike(UserList item){
            return new UserListNestedImpl(item);
    }

    public KubeSchemaFluent.UserListNested editUserList(){
            return withNewUserListLike(getUserList());
    }

    public KubeSchemaFluent.UserListNested editOrNewUserList(){
            return withNewUserListLike(getUserList() != null ? getUserList(): new UserListBuilder().build());
    }

    public KubeSchemaFluent.UserListNested editOrNewUserListLike(UserList item){
            return withNewUserListLike(getUserList() != null ? getUserList(): item);
    }

    
/**
 * This method has been deprecated, please use method buildWatchEvent instead.
 */
@Deprecated public WatchEvent getWatchEvent(){
            return this.watchEvent!=null?this.watchEvent.build():null;
    }

    public WatchEvent buildWatchEvent(){
            return this.watchEvent!=null?this.watchEvent.build():null;
    }

    public A withWatchEvent(WatchEvent watchEvent){
            _visitables.remove(this.watchEvent);
            if (watchEvent!=null){ this.watchEvent= new WatchEventBuilder(watchEvent); _visitables.add(this.watchEvent);} return (A) this;
    }

    public Boolean hasWatchEvent(){
            return this.watchEvent!=null;
    }

    public KubeSchemaFluent.WatchEventNested withNewWatchEvent(){
            return new WatchEventNestedImpl();
    }

    public KubeSchemaFluent.WatchEventNested withNewWatchEventLike(WatchEvent item){
            return new WatchEventNestedImpl(item);
    }

    public KubeSchemaFluent.WatchEventNested editWatchEvent(){
            return withNewWatchEventLike(getWatchEvent());
    }

    public KubeSchemaFluent.WatchEventNested editOrNewWatchEvent(){
            return withNewWatchEventLike(getWatchEvent() != null ? getWatchEvent(): new WatchEventBuilder().build());
    }

    public KubeSchemaFluent.WatchEventNested editOrNewWatchEventLike(WatchEvent item){
            return withNewWatchEventLike(getWatchEvent() != null ? getWatchEvent(): item);
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            KubeSchemaFluentImpl that = (KubeSchemaFluentImpl) o;
            if (baseKubernetesList != null ? !baseKubernetesList.equals(that.baseKubernetesList) :that.baseKubernetesList != null) return false;
            if (binding != null ? !binding.equals(that.binding) :that.binding != null) return false;
            if (buildConfigList != null ? !buildConfigList.equals(that.buildConfigList) :that.buildConfigList != null) return false;
            if (buildList != null ? !buildList.equals(that.buildList) :that.buildList != null) return false;
            if (buildRequest != null ? !buildRequest.equals(that.buildRequest) :that.buildRequest != null) return false;
            if (clusterPolicy != null ? !clusterPolicy.equals(that.clusterPolicy) :that.clusterPolicy != null) return false;
            if (clusterPolicyBinding != null ? !clusterPolicyBinding.equals(that.clusterPolicyBinding) :that.clusterPolicyBinding != null) return false;
            if (clusterPolicyBindingList != null ? !clusterPolicyBindingList.equals(that.clusterPolicyBindingList) :that.clusterPolicyBindingList != null) return false;
            if (clusterPolicyList != null ? !clusterPolicyList.equals(that.clusterPolicyList) :that.clusterPolicyList != null) return false;
            if (clusterRoleBinding != null ? !clusterRoleBinding.equals(that.clusterRoleBinding) :that.clusterRoleBinding != null) return false;
            if (clusterRoleBindingList != null ? !clusterRoleBindingList.equals(that.clusterRoleBindingList) :that.clusterRoleBindingList != null) return false;
            if (componentStatusList != null ? !componentStatusList.equals(that.componentStatusList) :that.componentStatusList != null) return false;
            if (config != null ? !config.equals(that.config) :that.config != null) return false;
            if (configMap != null ? !configMap.equals(that.configMap) :that.configMap != null) return false;
            if (configMapList != null ? !configMapList.equals(that.configMapList) :that.configMapList != null) return false;
            if (containerStatus != null ? !containerStatus.equals(that.containerStatus) :that.containerStatus != null) return false;
            if (cronJob != null ? !cronJob.equals(that.cronJob) :that.cronJob != null) return false;
            if (cronJobList != null ? !cronJobList.equals(that.cronJobList) :that.cronJobList != null) return false;
            if (customResourceDefinition != null ? !customResourceDefinition.equals(that.customResourceDefinition) :that.customResourceDefinition != null) return false;
            if (customResourceDefinitionCondition != null ? !customResourceDefinitionCondition.equals(that.customResourceDefinitionCondition) :that.customResourceDefinitionCondition != null) return false;
            if (customResourceDefinitionList != null ? !customResourceDefinitionList.equals(that.customResourceDefinitionList) :that.customResourceDefinitionList != null) return false;
            if (customResourceDefinitionNames != null ? !customResourceDefinitionNames.equals(that.customResourceDefinitionNames) :that.customResourceDefinitionNames != null) return false;
            if (customResourceDefinitionSpec != null ? !customResourceDefinitionSpec.equals(that.customResourceDefinitionSpec) :that.customResourceDefinitionSpec != null) return false;
            if (customResourceDefinitionStatus != null ? !customResourceDefinitionStatus.equals(that.customResourceDefinitionStatus) :that.customResourceDefinitionStatus != null) return false;
            if (daemonSet != null ? !daemonSet.equals(that.daemonSet) :that.daemonSet != null) return false;
            if (daemonSetList != null ? !daemonSetList.equals(that.daemonSetList) :that.daemonSetList != null) return false;
            if (deleteOptions != null ? !deleteOptions.equals(that.deleteOptions) :that.deleteOptions != null) return false;
            if (deployment != null ? !deployment.equals(that.deployment) :that.deployment != null) return false;
            if (deploymentConfig != null ? !deploymentConfig.equals(that.deploymentConfig) :that.deploymentConfig != null) return false;
            if (deploymentConfigList != null ? !deploymentConfigList.equals(that.deploymentConfigList) :that.deploymentConfigList != null) return false;
            if (deploymentList != null ? !deploymentList.equals(that.deploymentList) :that.deploymentList != null) return false;
            if (deploymentRollback != null ? !deploymentRollback.equals(that.deploymentRollback) :that.deploymentRollback != null) return false;
            if (endpoints != null ? !endpoints.equals(that.endpoints) :that.endpoints != null) return false;
            if (endpointsList != null ? !endpointsList.equals(that.endpointsList) :that.endpointsList != null) return false;
            if (envVar != null ? !envVar.equals(that.envVar) :that.envVar != null) return false;
            if (eventList != null ? !eventList.equals(that.eventList) :that.eventList != null) return false;
            if (group != null ? !group.equals(that.group) :that.group != null) return false;
            if (groupList != null ? !groupList.equals(that.groupList) :that.groupList != null) return false;
            if (horizontalPodAutoscaler != null ? !horizontalPodAutoscaler.equals(that.horizontalPodAutoscaler) :that.horizontalPodAutoscaler != null) return false;
            if (horizontalPodAutoscalerList != null ? !horizontalPodAutoscalerList.equals(that.horizontalPodAutoscalerList) :that.horizontalPodAutoscalerList != null) return false;
            if (identity != null ? !identity.equals(that.identity) :that.identity != null) return false;
            if (identityList != null ? !identityList.equals(that.identityList) :that.identityList != null) return false;
            if (imageList != null ? !imageList.equals(that.imageList) :that.imageList != null) return false;
            if (imageStreamList != null ? !imageStreamList.equals(that.imageStreamList) :that.imageStreamList != null) return false;
            if (imageStreamTagList != null ? !imageStreamTagList.equals(that.imageStreamTagList) :that.imageStreamTagList != null) return false;
            if (info != null ? !info.equals(that.info) :that.info != null) return false;
            if (ingress != null ? !ingress.equals(that.ingress) :that.ingress != null) return false;
            if (ingressList != null ? !ingressList.equals(that.ingressList) :that.ingressList != null) return false;
            if (jenkins != null ? !jenkins.equals(that.jenkins) :that.jenkins != null) return false;
            if (jenkinsBinding != null ? !jenkinsBinding.equals(that.jenkinsBinding) :that.jenkinsBinding != null) return false;
            if (jenkinsBindingList != null ? !jenkinsBindingList.equals(that.jenkinsBindingList) :that.jenkinsBindingList != null) return false;
            if (jenkinsList != null ? !jenkinsList.equals(that.jenkinsList) :that.jenkinsList != null) return false;
            if (job != null ? !job.equals(that.job) :that.job != null) return false;
            if (jobList != null ? !jobList.equals(that.jobList) :that.jobList != null) return false;
            if (k8sLocalSubjectAccessReview != null ? !k8sLocalSubjectAccessReview.equals(that.k8sLocalSubjectAccessReview) :that.k8sLocalSubjectAccessReview != null) return false;
            if (k8sSubjectAccessReview != null ? !k8sSubjectAccessReview.equals(that.k8sSubjectAccessReview) :that.k8sSubjectAccessReview != null) return false;
            if (limitRangeList != null ? !limitRangeList.equals(that.limitRangeList) :that.limitRangeList != null) return false;
            if (listMeta != null ? !listMeta.equals(that.listMeta) :that.listMeta != null) return false;
            if (localSubjectAccessReview != null ? !localSubjectAccessReview.equals(that.localSubjectAccessReview) :that.localSubjectAccessReview != null) return false;
            if (namespace != null ? !namespace.equals(that.namespace) :that.namespace != null) return false;
            if (namespaceList != null ? !namespaceList.equals(that.namespaceList) :that.namespaceList != null) return false;
            if (networkPolicy != null ? !networkPolicy.equals(that.networkPolicy) :that.networkPolicy != null) return false;
            if (networkPolicyList != null ? !networkPolicyList.equals(that.networkPolicyList) :that.networkPolicyList != null) return false;
            if (node != null ? !node.equals(that.node) :that.node != null) return false;
            if (nodeList != null ? !nodeList.equals(that.nodeList) :that.nodeList != null) return false;
            if (oAuthAccessToken != null ? !oAuthAccessToken.equals(that.oAuthAccessToken) :that.oAuthAccessToken != null) return false;
            if (oAuthAccessTokenList != null ? !oAuthAccessTokenList.equals(that.oAuthAccessTokenList) :that.oAuthAccessTokenList != null) return false;
            if (oAuthAuthorizeToken != null ? !oAuthAuthorizeToken.equals(that.oAuthAuthorizeToken) :that.oAuthAuthorizeToken != null) return false;
            if (oAuthAuthorizeTokenList != null ? !oAuthAuthorizeTokenList.equals(that.oAuthAuthorizeTokenList) :that.oAuthAuthorizeTokenList != null) return false;
            if (oAuthClient != null ? !oAuthClient.equals(that.oAuthClient) :that.oAuthClient != null) return false;
            if (oAuthClientAuthorization != null ? !oAuthClientAuthorization.equals(that.oAuthClientAuthorization) :that.oAuthClientAuthorization != null) return false;
            if (oAuthClientAuthorizationList != null ? !oAuthClientAuthorizationList.equals(that.oAuthClientAuthorizationList) :that.oAuthClientAuthorizationList != null) return false;
            if (oAuthClientList != null ? !oAuthClientList.equals(that.oAuthClientList) :that.oAuthClientList != null) return false;
            if (objectMeta != null ? !objectMeta.equals(that.objectMeta) :that.objectMeta != null) return false;
            if (patch != null ? !patch.equals(that.patch) :that.patch != null) return false;
            if (persistentVolume != null ? !persistentVolume.equals(that.persistentVolume) :that.persistentVolume != null) return false;
            if (persistentVolumeClaim != null ? !persistentVolumeClaim.equals(that.persistentVolumeClaim) :that.persistentVolumeClaim != null) return false;
            if (persistentVolumeClaimList != null ? !persistentVolumeClaimList.equals(that.persistentVolumeClaimList) :that.persistentVolumeClaimList != null) return false;
            if (persistentVolumeList != null ? !persistentVolumeList.equals(that.persistentVolumeList) :that.persistentVolumeList != null) return false;
            if (pipeline != null ? !pipeline.equals(that.pipeline) :that.pipeline != null) return false;
            if (pipelineConfig != null ? !pipelineConfig.equals(that.pipelineConfig) :that.pipelineConfig != null) return false;
            if (pipelineConfigList != null ? !pipelineConfigList.equals(that.pipelineConfigList) :that.pipelineConfigList != null) return false;
            if (pipelineList != null ? !pipelineList.equals(that.pipelineList) :that.pipelineList != null) return false;
            if (podDisruptionBudget != null ? !podDisruptionBudget.equals(that.podDisruptionBudget) :that.podDisruptionBudget != null) return false;
            if (podDisruptionBudgetList != null ? !podDisruptionBudgetList.equals(that.podDisruptionBudgetList) :that.podDisruptionBudgetList != null) return false;
            if (podList != null ? !podList.equals(that.podList) :that.podList != null) return false;
            if (podSecurityPolicy != null ? !podSecurityPolicy.equals(that.podSecurityPolicy) :that.podSecurityPolicy != null) return false;
            if (podSecurityPolicyList != null ? !podSecurityPolicyList.equals(that.podSecurityPolicyList) :that.podSecurityPolicyList != null) return false;
            if (podTemplateList != null ? !podTemplateList.equals(that.podTemplateList) :that.podTemplateList != null) return false;
            if (policy != null ? !policy.equals(that.policy) :that.policy != null) return false;
            if (policyBinding != null ? !policyBinding.equals(that.policyBinding) :that.policyBinding != null) return false;
            if (policyBindingList != null ? !policyBindingList.equals(that.policyBindingList) :that.policyBindingList != null) return false;
            if (policyList != null ? !policyList.equals(that.policyList) :that.policyList != null) return false;
            if (project != null ? !project.equals(that.project) :that.project != null) return false;
            if (projectList != null ? !projectList.equals(that.projectList) :that.projectList != null) return false;
            if (quantity != null ? !quantity.equals(that.quantity) :that.quantity != null) return false;
            if (replicaSet != null ? !replicaSet.equals(that.replicaSet) :that.replicaSet != null) return false;
            if (replicaSetList != null ? !replicaSetList.equals(that.replicaSetList) :that.replicaSetList != null) return false;
            if (replicationControllerList != null ? !replicationControllerList.equals(that.replicationControllerList) :that.replicationControllerList != null) return false;
            if (resourceQuota != null ? !resourceQuota.equals(that.resourceQuota) :that.resourceQuota != null) return false;
            if (resourceQuotaList != null ? !resourceQuotaList.equals(that.resourceQuotaList) :that.resourceQuotaList != null) return false;
            if (role != null ? !role.equals(that.role) :that.role != null) return false;
            if (roleBinding != null ? !roleBinding.equals(that.roleBinding) :that.roleBinding != null) return false;
            if (roleBindingList != null ? !roleBindingList.equals(that.roleBindingList) :that.roleBindingList != null) return false;
            if (roleBindingRestriction != null ? !roleBindingRestriction.equals(that.roleBindingRestriction) :that.roleBindingRestriction != null) return false;
            if (roleList != null ? !roleList.equals(that.roleList) :that.roleList != null) return false;
            if (rootPaths != null ? !rootPaths.equals(that.rootPaths) :that.rootPaths != null) return false;
            if (route != null ? !route.equals(that.route) :that.route != null) return false;
            if (routeList != null ? !routeList.equals(that.routeList) :that.routeList != null) return false;
            if (scale != null ? !scale.equals(that.scale) :that.scale != null) return false;
            if (secret != null ? !secret.equals(that.secret) :that.secret != null) return false;
            if (secretList != null ? !secretList.equals(that.secretList) :that.secretList != null) return false;
            if (securityContextConstraints != null ? !securityContextConstraints.equals(that.securityContextConstraints) :that.securityContextConstraints != null) return false;
            if (securityContextConstraintsList != null ? !securityContextConstraintsList.equals(that.securityContextConstraintsList) :that.securityContextConstraintsList != null) return false;
            if (serviceAccount != null ? !serviceAccount.equals(that.serviceAccount) :that.serviceAccount != null) return false;
            if (serviceAccountList != null ? !serviceAccountList.equals(that.serviceAccountList) :that.serviceAccountList != null) return false;
            if (serviceList != null ? !serviceList.equals(that.serviceList) :that.serviceList != null) return false;
            if (statefulSet != null ? !statefulSet.equals(that.statefulSet) :that.statefulSet != null) return false;
            if (statefulSetList != null ? !statefulSetList.equals(that.statefulSetList) :that.statefulSetList != null) return false;
            if (status != null ? !status.equals(that.status) :that.status != null) return false;
            if (storageClass != null ? !storageClass.equals(that.storageClass) :that.storageClass != null) return false;
            if (storageClassList != null ? !storageClassList.equals(that.storageClassList) :that.storageClassList != null) return false;
            if (subjectAccessReview != null ? !subjectAccessReview.equals(that.subjectAccessReview) :that.subjectAccessReview != null) return false;
            if (subjectAccessReviewResponse != null ? !subjectAccessReviewResponse.equals(that.subjectAccessReviewResponse) :that.subjectAccessReviewResponse != null) return false;
            if (tagEvent != null ? !tagEvent.equals(that.tagEvent) :that.tagEvent != null) return false;
            if (template != null ? !template.equals(that.template) :that.template != null) return false;
            if (templateList != null ? !templateList.equals(that.templateList) :that.templateList != null) return false;
            if (thirdPartyResource != null ? !thirdPartyResource.equals(that.thirdPartyResource) :that.thirdPartyResource != null) return false;
            if (thirdPartyResourceList != null ? !thirdPartyResourceList.equals(that.thirdPartyResourceList) :that.thirdPartyResourceList != null) return false;
            if (tokenReview != null ? !tokenReview.equals(that.tokenReview) :that.tokenReview != null) return false;
            if (toleration != null ? !toleration.equals(that.toleration) :that.toleration != null) return false;
            if (user != null ? !user.equals(that.user) :that.user != null) return false;
            if (userList != null ? !userList.equals(that.userList) :that.userList != null) return false;
            if (watchEvent != null ? !watchEvent.equals(that.watchEvent) :that.watchEvent != null) return false;
            return true;
    }


    public class BaseKubernetesListNestedImpl extends BaseKubernetesListFluentImpl> implements KubeSchemaFluent.BaseKubernetesListNested,io.alauda.kubernetes.api.builder.Nested{

            private final BaseKubernetesListBuilder builder;
    
            BaseKubernetesListNestedImpl(BaseKubernetesList item){
                    this.builder = new BaseKubernetesListBuilder(this, item);
            }
            BaseKubernetesListNestedImpl(){
                    this.builder = new BaseKubernetesListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withBaseKubernetesList(builder.build());
    }
    public N endBaseKubernetesList(){
            return and();
    }

}
    public class BindingNestedImpl extends BindingFluentImpl> implements KubeSchemaFluent.BindingNested,io.alauda.kubernetes.api.builder.Nested{

            private final BindingBuilder builder;
    
            BindingNestedImpl(Binding item){
                    this.builder = new BindingBuilder(this, item);
            }
            BindingNestedImpl(){
                    this.builder = new BindingBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withBinding(builder.build());
    }
    public N endBinding(){
            return and();
    }

}
    public class BuildConfigListNestedImpl extends BuildConfigListFluentImpl> implements KubeSchemaFluent.BuildConfigListNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildConfigListBuilder builder;
    
            BuildConfigListNestedImpl(BuildConfigList item){
                    this.builder = new BuildConfigListBuilder(this, item);
            }
            BuildConfigListNestedImpl(){
                    this.builder = new BuildConfigListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withBuildConfigList(builder.build());
    }
    public N endBuildConfigList(){
            return and();
    }

}
    public class BuildListNestedImpl extends BuildListFluentImpl> implements KubeSchemaFluent.BuildListNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildListBuilder builder;
    
            BuildListNestedImpl(BuildList item){
                    this.builder = new BuildListBuilder(this, item);
            }
            BuildListNestedImpl(){
                    this.builder = new BuildListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withBuildList(builder.build());
    }
    public N endBuildList(){
            return and();
    }

}
    public class BuildRequestNestedImpl extends BuildRequestFluentImpl> implements KubeSchemaFluent.BuildRequestNested,io.alauda.kubernetes.api.builder.Nested{

            private final BuildRequestBuilder builder;
    
            BuildRequestNestedImpl(BuildRequest item){
                    this.builder = new BuildRequestBuilder(this, item);
            }
            BuildRequestNestedImpl(){
                    this.builder = new BuildRequestBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withBuildRequest(builder.build());
    }
    public N endBuildRequest(){
            return and();
    }

}
    public class ClusterPolicyNestedImpl extends ClusterPolicyFluentImpl> implements KubeSchemaFluent.ClusterPolicyNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBuilder builder;
    
            ClusterPolicyNestedImpl(ClusterPolicy item){
                    this.builder = new ClusterPolicyBuilder(this, item);
            }
            ClusterPolicyNestedImpl(){
                    this.builder = new ClusterPolicyBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withClusterPolicy(builder.build());
    }
    public N endClusterPolicy(){
            return and();
    }

}
    public class ClusterPolicyBindingNestedImpl extends ClusterPolicyBindingFluentImpl> implements KubeSchemaFluent.ClusterPolicyBindingNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBindingBuilder builder;
    
            ClusterPolicyBindingNestedImpl(ClusterPolicyBinding item){
                    this.builder = new ClusterPolicyBindingBuilder(this, item);
            }
            ClusterPolicyBindingNestedImpl(){
                    this.builder = new ClusterPolicyBindingBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withClusterPolicyBinding(builder.build());
    }
    public N endClusterPolicyBinding(){
            return and();
    }

}
    public class ClusterPolicyBindingListNestedImpl extends ClusterPolicyBindingListFluentImpl> implements KubeSchemaFluent.ClusterPolicyBindingListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyBindingListBuilder builder;
    
            ClusterPolicyBindingListNestedImpl(ClusterPolicyBindingList item){
                    this.builder = new ClusterPolicyBindingListBuilder(this, item);
            }
            ClusterPolicyBindingListNestedImpl(){
                    this.builder = new ClusterPolicyBindingListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withClusterPolicyBindingList(builder.build());
    }
    public N endClusterPolicyBindingList(){
            return and();
    }

}
    public class ClusterPolicyListNestedImpl extends ClusterPolicyListFluentImpl> implements KubeSchemaFluent.ClusterPolicyListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPolicyListBuilder builder;
    
            ClusterPolicyListNestedImpl(ClusterPolicyList item){
                    this.builder = new ClusterPolicyListBuilder(this, item);
            }
            ClusterPolicyListNestedImpl(){
                    this.builder = new ClusterPolicyListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withClusterPolicyList(builder.build());
    }
    public N endClusterPolicyList(){
            return and();
    }

}
    public class ClusterRoleBindingNestedImpl extends ClusterRoleBindingFluentImpl> implements KubeSchemaFluent.ClusterRoleBindingNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterRoleBindingBuilder builder;
    
            ClusterRoleBindingNestedImpl(ClusterRoleBinding item){
                    this.builder = new ClusterRoleBindingBuilder(this, item);
            }
            ClusterRoleBindingNestedImpl(){
                    this.builder = new ClusterRoleBindingBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withClusterRoleBinding(builder.build());
    }
    public N endClusterRoleBinding(){
            return and();
    }

}
    public class ClusterRoleBindingListNestedImpl extends ClusterRoleBindingListFluentImpl> implements KubeSchemaFluent.ClusterRoleBindingListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterRoleBindingListBuilder builder;
    
            ClusterRoleBindingListNestedImpl(ClusterRoleBindingList item){
                    this.builder = new ClusterRoleBindingListBuilder(this, item);
            }
            ClusterRoleBindingListNestedImpl(){
                    this.builder = new ClusterRoleBindingListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withClusterRoleBindingList(builder.build());
    }
    public N endClusterRoleBindingList(){
            return and();
    }

}
    public class ComponentStatusListNestedImpl extends ComponentStatusListFluentImpl> implements KubeSchemaFluent.ComponentStatusListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentStatusListBuilder builder;
    
            ComponentStatusListNestedImpl(ComponentStatusList item){
                    this.builder = new ComponentStatusListBuilder(this, item);
            }
            ComponentStatusListNestedImpl(){
                    this.builder = new ComponentStatusListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withComponentStatusList(builder.build());
    }
    public N endComponentStatusList(){
            return and();
    }

}
    public class ConfigNestedImpl extends ConfigFluentImpl> implements KubeSchemaFluent.ConfigNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigBuilder builder;
    
            ConfigNestedImpl(Config item){
                    this.builder = new ConfigBuilder(this, item);
            }
            ConfigNestedImpl(){
                    this.builder = new ConfigBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withConfig(builder.build());
    }
    public N endConfig(){
            return and();
    }

}
    public class ConfigMapNestedImpl extends ConfigMapFluentImpl> implements KubeSchemaFluent.ConfigMapNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapBuilder builder;
    
            ConfigMapNestedImpl(ConfigMap item){
                    this.builder = new ConfigMapBuilder(this, item);
            }
            ConfigMapNestedImpl(){
                    this.builder = new ConfigMapBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withConfigMap(builder.build());
    }
    public N endConfigMap(){
            return and();
    }

}
    public class ConfigMapListNestedImpl extends ConfigMapListFluentImpl> implements KubeSchemaFluent.ConfigMapListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapListBuilder builder;
    
            ConfigMapListNestedImpl(ConfigMapList item){
                    this.builder = new ConfigMapListBuilder(this, item);
            }
            ConfigMapListNestedImpl(){
                    this.builder = new ConfigMapListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withConfigMapList(builder.build());
    }
    public N endConfigMapList(){
            return and();
    }

}
    public class ContainerStatusNestedImpl extends ContainerStatusFluentImpl> implements KubeSchemaFluent.ContainerStatusNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerStatusBuilder builder;
    
            ContainerStatusNestedImpl(ContainerStatus item){
                    this.builder = new ContainerStatusBuilder(this, item);
            }
            ContainerStatusNestedImpl(){
                    this.builder = new ContainerStatusBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withContainerStatus(builder.build());
    }
    public N endContainerStatus(){
            return and();
    }

}
    public class CronJobNestedImpl extends CronJobFluentImpl> implements KubeSchemaFluent.CronJobNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobBuilder builder;
    
            CronJobNestedImpl(CronJob item){
                    this.builder = new CronJobBuilder(this, item);
            }
            CronJobNestedImpl(){
                    this.builder = new CronJobBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCronJob(builder.build());
    }
    public N endCronJob(){
            return and();
    }

}
    public class CronJobListNestedImpl extends CronJobListFluentImpl> implements KubeSchemaFluent.CronJobListNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobListBuilder builder;
    
            CronJobListNestedImpl(CronJobList item){
                    this.builder = new CronJobListBuilder(this, item);
            }
            CronJobListNestedImpl(){
                    this.builder = new CronJobListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCronJobList(builder.build());
    }
    public N endCronJobList(){
            return and();
    }

}
    public class CustomResourceDefinitionNestedImpl extends CustomResourceDefinitionFluentImpl> implements KubeSchemaFluent.CustomResourceDefinitionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionBuilder builder;
    
            CustomResourceDefinitionNestedImpl(CustomResourceDefinition item){
                    this.builder = new CustomResourceDefinitionBuilder(this, item);
            }
            CustomResourceDefinitionNestedImpl(){
                    this.builder = new CustomResourceDefinitionBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCustomResourceDefinition(builder.build());
    }
    public N endCustomResourceDefinition(){
            return and();
    }

}
    public class CustomResourceDefinitionConditionNestedImpl extends CustomResourceDefinitionConditionFluentImpl> implements KubeSchemaFluent.CustomResourceDefinitionConditionNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionConditionBuilder builder;
    
            CustomResourceDefinitionConditionNestedImpl(CustomResourceDefinitionCondition item){
                    this.builder = new CustomResourceDefinitionConditionBuilder(this, item);
            }
            CustomResourceDefinitionConditionNestedImpl(){
                    this.builder = new CustomResourceDefinitionConditionBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCustomResourceDefinitionCondition(builder.build());
    }
    public N endCustomResourceDefinitionCondition(){
            return and();
    }

}
    public class CustomResourceDefinitionListNestedImpl extends CustomResourceDefinitionListFluentImpl> implements KubeSchemaFluent.CustomResourceDefinitionListNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionListBuilder builder;
    
            CustomResourceDefinitionListNestedImpl(CustomResourceDefinitionList item){
                    this.builder = new CustomResourceDefinitionListBuilder(this, item);
            }
            CustomResourceDefinitionListNestedImpl(){
                    this.builder = new CustomResourceDefinitionListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCustomResourceDefinitionList(builder.build());
    }
    public N endCustomResourceDefinitionList(){
            return and();
    }

}
    public class CustomResourceDefinitionNamesNestedImpl extends CustomResourceDefinitionNamesFluentImpl> implements KubeSchemaFluent.CustomResourceDefinitionNamesNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionNamesBuilder builder;
    
            CustomResourceDefinitionNamesNestedImpl(CustomResourceDefinitionNames item){
                    this.builder = new CustomResourceDefinitionNamesBuilder(this, item);
            }
            CustomResourceDefinitionNamesNestedImpl(){
                    this.builder = new CustomResourceDefinitionNamesBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCustomResourceDefinitionNames(builder.build());
    }
    public N endCustomResourceDefinitionNames(){
            return and();
    }

}
    public class CustomResourceDefinitionSpecNestedImpl extends CustomResourceDefinitionSpecFluentImpl> implements KubeSchemaFluent.CustomResourceDefinitionSpecNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionSpecBuilder builder;
    
            CustomResourceDefinitionSpecNestedImpl(CustomResourceDefinitionSpec item){
                    this.builder = new CustomResourceDefinitionSpecBuilder(this, item);
            }
            CustomResourceDefinitionSpecNestedImpl(){
                    this.builder = new CustomResourceDefinitionSpecBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCustomResourceDefinitionSpec(builder.build());
    }
    public N endCustomResourceDefinitionSpec(){
            return and();
    }

}
    public class CustomResourceDefinitionStatusNestedImpl extends CustomResourceDefinitionStatusFluentImpl> implements KubeSchemaFluent.CustomResourceDefinitionStatusNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionStatusBuilder builder;
    
            CustomResourceDefinitionStatusNestedImpl(CustomResourceDefinitionStatus item){
                    this.builder = new CustomResourceDefinitionStatusBuilder(this, item);
            }
            CustomResourceDefinitionStatusNestedImpl(){
                    this.builder = new CustomResourceDefinitionStatusBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withCustomResourceDefinitionStatus(builder.build());
    }
    public N endCustomResourceDefinitionStatus(){
            return and();
    }

}
    public class DaemonSetNestedImpl extends DaemonSetFluentImpl> implements KubeSchemaFluent.DaemonSetNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetBuilder builder;
    
            DaemonSetNestedImpl(DaemonSet item){
                    this.builder = new DaemonSetBuilder(this, item);
            }
            DaemonSetNestedImpl(){
                    this.builder = new DaemonSetBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDaemonSet(builder.build());
    }
    public N endDaemonSet(){
            return and();
    }

}
    public class DaemonSetListNestedImpl extends DaemonSetListFluentImpl> implements KubeSchemaFluent.DaemonSetListNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetListBuilder builder;
    
            DaemonSetListNestedImpl(DaemonSetList item){
                    this.builder = new DaemonSetListBuilder(this, item);
            }
            DaemonSetListNestedImpl(){
                    this.builder = new DaemonSetListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDaemonSetList(builder.build());
    }
    public N endDaemonSetList(){
            return and();
    }

}
    public class DeleteOptionsNestedImpl extends DeleteOptionsFluentImpl> implements KubeSchemaFluent.DeleteOptionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeleteOptionsBuilder builder;
    
            DeleteOptionsNestedImpl(DeleteOptions item){
                    this.builder = new DeleteOptionsBuilder(this, item);
            }
            DeleteOptionsNestedImpl(){
                    this.builder = new DeleteOptionsBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDeleteOptions(builder.build());
    }
    public N endDeleteOptions(){
            return and();
    }

}
    public class DeploymentNestedImpl extends DeploymentFluentImpl> implements KubeSchemaFluent.DeploymentNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentBuilder builder;
    
            DeploymentNestedImpl(Deployment item){
                    this.builder = new DeploymentBuilder(this, item);
            }
            DeploymentNestedImpl(){
                    this.builder = new DeploymentBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDeployment(builder.build());
    }
    public N endDeployment(){
            return and();
    }

}
    public class DeploymentConfigNestedImpl extends DeploymentConfigFluentImpl> implements KubeSchemaFluent.DeploymentConfigNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentConfigBuilder builder;
    
            DeploymentConfigNestedImpl(DeploymentConfig item){
                    this.builder = new DeploymentConfigBuilder(this, item);
            }
            DeploymentConfigNestedImpl(){
                    this.builder = new DeploymentConfigBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDeploymentConfig(builder.build());
    }
    public N endDeploymentConfig(){
            return and();
    }

}
    public class DeploymentConfigListNestedImpl extends DeploymentConfigListFluentImpl> implements KubeSchemaFluent.DeploymentConfigListNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentConfigListBuilder builder;
    
            DeploymentConfigListNestedImpl(DeploymentConfigList item){
                    this.builder = new DeploymentConfigListBuilder(this, item);
            }
            DeploymentConfigListNestedImpl(){
                    this.builder = new DeploymentConfigListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDeploymentConfigList(builder.build());
    }
    public N endDeploymentConfigList(){
            return and();
    }

}
    public class DeploymentListNestedImpl extends DeploymentListFluentImpl> implements KubeSchemaFluent.DeploymentListNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentListBuilder builder;
    
            DeploymentListNestedImpl(DeploymentList item){
                    this.builder = new DeploymentListBuilder(this, item);
            }
            DeploymentListNestedImpl(){
                    this.builder = new DeploymentListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDeploymentList(builder.build());
    }
    public N endDeploymentList(){
            return and();
    }

}
    public class DeploymentRollbackNestedImpl extends DeploymentRollbackFluentImpl> implements KubeSchemaFluent.DeploymentRollbackNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentRollbackBuilder builder;
    
            DeploymentRollbackNestedImpl(DeploymentRollback item){
                    this.builder = new DeploymentRollbackBuilder(this, item);
            }
            DeploymentRollbackNestedImpl(){
                    this.builder = new DeploymentRollbackBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withDeploymentRollback(builder.build());
    }
    public N endDeploymentRollback(){
            return and();
    }

}
    public class EndpointsNestedImpl extends EndpointsFluentImpl> implements KubeSchemaFluent.EndpointsNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsBuilder builder;
    
            EndpointsNestedImpl(Endpoints item){
                    this.builder = new EndpointsBuilder(this, item);
            }
            EndpointsNestedImpl(){
                    this.builder = new EndpointsBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withEndpoints(builder.build());
    }
    public N endEndpoints(){
            return and();
    }

}
    public class EndpointsListNestedImpl extends EndpointsListFluentImpl> implements KubeSchemaFluent.EndpointsListNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsListBuilder builder;
    
            EndpointsListNestedImpl(EndpointsList item){
                    this.builder = new EndpointsListBuilder(this, item);
            }
            EndpointsListNestedImpl(){
                    this.builder = new EndpointsListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withEndpointsList(builder.build());
    }
    public N endEndpointsList(){
            return and();
    }

}
    public class EnvVarNestedImpl extends EnvVarFluentImpl> implements KubeSchemaFluent.EnvVarNested,io.alauda.kubernetes.api.builder.Nested{

            private final EnvVarBuilder builder;
    
            EnvVarNestedImpl(EnvVar item){
                    this.builder = new EnvVarBuilder(this, item);
            }
            EnvVarNestedImpl(){
                    this.builder = new EnvVarBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withEnvVar(builder.build());
    }
    public N endEnvVar(){
            return and();
    }

}
    public class EventListNestedImpl extends EventListFluentImpl> implements KubeSchemaFluent.EventListNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventListBuilder builder;
    
            EventListNestedImpl(EventList item){
                    this.builder = new EventListBuilder(this, item);
            }
            EventListNestedImpl(){
                    this.builder = new EventListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withEventList(builder.build());
    }
    public N endEventList(){
            return and();
    }

}
    public class GroupNestedImpl extends GroupFluentImpl> implements KubeSchemaFluent.GroupNested,io.alauda.kubernetes.api.builder.Nested{

            private final GroupBuilder builder;
    
            GroupNestedImpl(Group item){
                    this.builder = new GroupBuilder(this, item);
            }
            GroupNestedImpl(){
                    this.builder = new GroupBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withGroup(builder.build());
    }
    public N endGroup(){
            return and();
    }

}
    public class GroupListNestedImpl extends GroupListFluentImpl> implements KubeSchemaFluent.GroupListNested,io.alauda.kubernetes.api.builder.Nested{

            private final GroupListBuilder builder;
    
            GroupListNestedImpl(GroupList item){
                    this.builder = new GroupListBuilder(this, item);
            }
            GroupListNestedImpl(){
                    this.builder = new GroupListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withGroupList(builder.build());
    }
    public N endGroupList(){
            return and();
    }

}
    public class HorizontalPodAutoscalerNestedImpl extends HorizontalPodAutoscalerFluentImpl> implements KubeSchemaFluent.HorizontalPodAutoscalerNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerBuilder builder;
    
            HorizontalPodAutoscalerNestedImpl(HorizontalPodAutoscaler item){
                    this.builder = new HorizontalPodAutoscalerBuilder(this, item);
            }
            HorizontalPodAutoscalerNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withHorizontalPodAutoscaler(builder.build());
    }
    public N endHorizontalPodAutoscaler(){
            return and();
    }

}
    public class HorizontalPodAutoscalerListNestedImpl extends HorizontalPodAutoscalerListFluentImpl> implements KubeSchemaFluent.HorizontalPodAutoscalerListNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerListBuilder builder;
    
            HorizontalPodAutoscalerListNestedImpl(HorizontalPodAutoscalerList item){
                    this.builder = new HorizontalPodAutoscalerListBuilder(this, item);
            }
            HorizontalPodAutoscalerListNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withHorizontalPodAutoscalerList(builder.build());
    }
    public N endHorizontalPodAutoscalerList(){
            return and();
    }

}
    public class IdentityNestedImpl extends IdentityFluentImpl> implements KubeSchemaFluent.IdentityNested,io.alauda.kubernetes.api.builder.Nested{

            private final IdentityBuilder builder;
    
            IdentityNestedImpl(Identity item){
                    this.builder = new IdentityBuilder(this, item);
            }
            IdentityNestedImpl(){
                    this.builder = new IdentityBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withIdentity(builder.build());
    }
    public N endIdentity(){
            return and();
    }

}
    public class IdentityListNestedImpl extends IdentityListFluentImpl> implements KubeSchemaFluent.IdentityListNested,io.alauda.kubernetes.api.builder.Nested{

            private final IdentityListBuilder builder;
    
            IdentityListNestedImpl(IdentityList item){
                    this.builder = new IdentityListBuilder(this, item);
            }
            IdentityListNestedImpl(){
                    this.builder = new IdentityListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withIdentityList(builder.build());
    }
    public N endIdentityList(){
            return and();
    }

}
    public class ImageListNestedImpl extends ImageListFluentImpl> implements KubeSchemaFluent.ImageListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageListBuilder builder;
    
            ImageListNestedImpl(ImageList item){
                    this.builder = new ImageListBuilder(this, item);
            }
            ImageListNestedImpl(){
                    this.builder = new ImageListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withImageList(builder.build());
    }
    public N endImageList(){
            return and();
    }

}
    public class ImageStreamListNestedImpl extends ImageStreamListFluentImpl> implements KubeSchemaFluent.ImageStreamListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageStreamListBuilder builder;
    
            ImageStreamListNestedImpl(ImageStreamList item){
                    this.builder = new ImageStreamListBuilder(this, item);
            }
            ImageStreamListNestedImpl(){
                    this.builder = new ImageStreamListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withImageStreamList(builder.build());
    }
    public N endImageStreamList(){
            return and();
    }

}
    public class ImageStreamTagListNestedImpl extends ImageStreamTagListFluentImpl> implements KubeSchemaFluent.ImageStreamTagListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ImageStreamTagListBuilder builder;
    
            ImageStreamTagListNestedImpl(ImageStreamTagList item){
                    this.builder = new ImageStreamTagListBuilder(this, item);
            }
            ImageStreamTagListNestedImpl(){
                    this.builder = new ImageStreamTagListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withImageStreamTagList(builder.build());
    }
    public N endImageStreamTagList(){
            return and();
    }

}
    public class InfoNestedImpl extends InfoFluentImpl> implements KubeSchemaFluent.InfoNested,io.alauda.kubernetes.api.builder.Nested{

            private final InfoBuilder builder;
    
            InfoNestedImpl(Info item){
                    this.builder = new InfoBuilder(this, item);
            }
            InfoNestedImpl(){
                    this.builder = new InfoBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withInfo(builder.build());
    }
    public N endInfo(){
            return and();
    }

}
    public class IngressNestedImpl extends IngressFluentImpl> implements KubeSchemaFluent.IngressNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressBuilder builder;
    
            IngressNestedImpl(Ingress item){
                    this.builder = new IngressBuilder(this, item);
            }
            IngressNestedImpl(){
                    this.builder = new IngressBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withIngress(builder.build());
    }
    public N endIngress(){
            return and();
    }

}
    public class IngressListNestedImpl extends IngressListFluentImpl> implements KubeSchemaFluent.IngressListNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressListBuilder builder;
    
            IngressListNestedImpl(IngressList item){
                    this.builder = new IngressListBuilder(this, item);
            }
            IngressListNestedImpl(){
                    this.builder = new IngressListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withIngressList(builder.build());
    }
    public N endIngressList(){
            return and();
    }

}
    public class JenkinsNestedImpl extends JenkinsFluentImpl> implements KubeSchemaFluent.JenkinsNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBuilder builder;
    
            JenkinsNestedImpl(Jenkins item){
                    this.builder = new JenkinsBuilder(this, item);
            }
            JenkinsNestedImpl(){
                    this.builder = new JenkinsBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withJenkins(builder.build());
    }
    public N endJenkins(){
            return and();
    }

}
    public class JenkinsBindingNestedImpl extends JenkinsBindingFluentImpl> implements KubeSchemaFluent.JenkinsBindingNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingBuilder builder;
    
            JenkinsBindingNestedImpl(JenkinsBinding item){
                    this.builder = new JenkinsBindingBuilder(this, item);
            }
            JenkinsBindingNestedImpl(){
                    this.builder = new JenkinsBindingBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withJenkinsBinding(builder.build());
    }
    public N endJenkinsBinding(){
            return and();
    }

}
    public class JenkinsBindingListNestedImpl extends JenkinsBindingListFluentImpl> implements KubeSchemaFluent.JenkinsBindingListNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingListBuilder builder;
    
            JenkinsBindingListNestedImpl(JenkinsBindingList item){
                    this.builder = new JenkinsBindingListBuilder(this, item);
            }
            JenkinsBindingListNestedImpl(){
                    this.builder = new JenkinsBindingListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withJenkinsBindingList(builder.build());
    }
    public N endJenkinsBindingList(){
            return and();
    }

}
    public class JenkinsListNestedImpl extends JenkinsListFluentImpl> implements KubeSchemaFluent.JenkinsListNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsListBuilder builder;
    
            JenkinsListNestedImpl(JenkinsList item){
                    this.builder = new JenkinsListBuilder(this, item);
            }
            JenkinsListNestedImpl(){
                    this.builder = new JenkinsListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withJenkinsList(builder.build());
    }
    public N endJenkinsList(){
            return and();
    }

}
    public class JobNestedImpl extends JobFluentImpl> implements KubeSchemaFluent.JobNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobBuilder builder;
    
            JobNestedImpl(Job item){
                    this.builder = new JobBuilder(this, item);
            }
            JobNestedImpl(){
                    this.builder = new JobBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withJob(builder.build());
    }
    public N endJob(){
            return and();
    }

}
    public class JobListNestedImpl extends JobListFluentImpl> implements KubeSchemaFluent.JobListNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobListBuilder builder;
    
            JobListNestedImpl(JobList item){
                    this.builder = new JobListBuilder(this, item);
            }
            JobListNestedImpl(){
                    this.builder = new JobListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withJobList(builder.build());
    }
    public N endJobList(){
            return and();
    }

}
    public class AuthorizationK8sLocalSubjectAccessReviewNestedImpl extends io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewFluentImpl> implements KubeSchemaFluent.AuthorizationK8sLocalSubjectAccessReviewNested,io.alauda.kubernetes.api.builder.Nested{

            private final io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder builder;
    
            AuthorizationK8sLocalSubjectAccessReviewNestedImpl(io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview item){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(this, item);
            }
            AuthorizationK8sLocalSubjectAccessReviewNestedImpl(){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withK8sLocalSubjectAccessReview(builder.build());
    }
    public N endAuthorizationK8sLocalSubjectAccessReview(){
            return and();
    }

}
    public class AuthorizationK8sSubjectAccessReviewNestedImpl extends io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewFluentImpl> implements KubeSchemaFluent.AuthorizationK8sSubjectAccessReviewNested,io.alauda.kubernetes.api.builder.Nested{

            private final io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder builder;
    
            AuthorizationK8sSubjectAccessReviewNestedImpl(io.alauda.kubernetes.api.model.authorization.SubjectAccessReview item){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder(this, item);
            }
            AuthorizationK8sSubjectAccessReviewNestedImpl(){
                    this.builder = new io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withK8sSubjectAccessReview(builder.build());
    }
    public N endAuthorizationK8sSubjectAccessReview(){
            return and();
    }

}
    public class LimitRangeListNestedImpl extends LimitRangeListFluentImpl> implements KubeSchemaFluent.LimitRangeListNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeListBuilder builder;
    
            LimitRangeListNestedImpl(LimitRangeList item){
                    this.builder = new LimitRangeListBuilder(this, item);
            }
            LimitRangeListNestedImpl(){
                    this.builder = new LimitRangeListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withLimitRangeList(builder.build());
    }
    public N endLimitRangeList(){
            return and();
    }

}
    public class ListMetaNestedImpl extends ListMetaFluentImpl> implements KubeSchemaFluent.ListMetaNested,io.alauda.kubernetes.api.builder.Nested{

            private final ListMetaBuilder builder;
    
            ListMetaNestedImpl(ListMeta item){
                    this.builder = new ListMetaBuilder(this, item);
            }
            ListMetaNestedImpl(){
                    this.builder = new ListMetaBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withListMeta(builder.build());
    }
    public N endListMeta(){
            return and();
    }

}
    public class LocalSubjectAccessReviewNestedImpl extends LocalSubjectAccessReviewFluentImpl> implements KubeSchemaFluent.LocalSubjectAccessReviewNested,io.alauda.kubernetes.api.builder.Nested{

            private final LocalSubjectAccessReviewBuilder builder;
    
            LocalSubjectAccessReviewNestedImpl(LocalSubjectAccessReview item){
                    this.builder = new LocalSubjectAccessReviewBuilder(this, item);
            }
            LocalSubjectAccessReviewNestedImpl(){
                    this.builder = new LocalSubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withLocalSubjectAccessReview(builder.build());
    }
    public N endLocalSubjectAccessReview(){
            return and();
    }

}
    public class NamespaceNestedImpl extends NamespaceFluentImpl> implements KubeSchemaFluent.NamespaceNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceBuilder builder;
    
            NamespaceNestedImpl(Namespace item){
                    this.builder = new NamespaceBuilder(this, item);
            }
            NamespaceNestedImpl(){
                    this.builder = new NamespaceBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withNamespace(builder.build());
    }
    public N endNamespace(){
            return and();
    }

}
    public class NamespaceListNestedImpl extends NamespaceListFluentImpl> implements KubeSchemaFluent.NamespaceListNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceListBuilder builder;
    
            NamespaceListNestedImpl(NamespaceList item){
                    this.builder = new NamespaceListBuilder(this, item);
            }
            NamespaceListNestedImpl(){
                    this.builder = new NamespaceListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withNamespaceList(builder.build());
    }
    public N endNamespaceList(){
            return and();
    }

}
    public class NetworkPolicyNestedImpl extends NetworkPolicyFluentImpl> implements KubeSchemaFluent.NetworkPolicyNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyBuilder builder;
    
            NetworkPolicyNestedImpl(NetworkPolicy item){
                    this.builder = new NetworkPolicyBuilder(this, item);
            }
            NetworkPolicyNestedImpl(){
                    this.builder = new NetworkPolicyBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withNetworkPolicy(builder.build());
    }
    public N endNetworkPolicy(){
            return and();
    }

}
    public class NetworkPolicyListNestedImpl extends NetworkPolicyListFluentImpl> implements KubeSchemaFluent.NetworkPolicyListNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyListBuilder builder;
    
            NetworkPolicyListNestedImpl(NetworkPolicyList item){
                    this.builder = new NetworkPolicyListBuilder(this, item);
            }
            NetworkPolicyListNestedImpl(){
                    this.builder = new NetworkPolicyListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withNetworkPolicyList(builder.build());
    }
    public N endNetworkPolicyList(){
            return and();
    }

}
    public class NodeNestedImpl extends NodeFluentImpl> implements KubeSchemaFluent.NodeNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeBuilder builder;
    
            NodeNestedImpl(Node item){
                    this.builder = new NodeBuilder(this, item);
            }
            NodeNestedImpl(){
                    this.builder = new NodeBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withNode(builder.build());
    }
    public N endNode(){
            return and();
    }

}
    public class NodeListNestedImpl extends NodeListFluentImpl> implements KubeSchemaFluent.NodeListNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeListBuilder builder;
    
            NodeListNestedImpl(NodeList item){
                    this.builder = new NodeListBuilder(this, item);
            }
            NodeListNestedImpl(){
                    this.builder = new NodeListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withNodeList(builder.build());
    }
    public N endNodeList(){
            return and();
    }

}
    public class OAuthAccessTokenNestedImpl extends OAuthAccessTokenFluentImpl> implements KubeSchemaFluent.OAuthAccessTokenNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAccessTokenBuilder builder;
    
            OAuthAccessTokenNestedImpl(OAuthAccessToken item){
                    this.builder = new OAuthAccessTokenBuilder(this, item);
            }
            OAuthAccessTokenNestedImpl(){
                    this.builder = new OAuthAccessTokenBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthAccessToken(builder.build());
    }
    public N endOAuthAccessToken(){
            return and();
    }

}
    public class OAuthAccessTokenListNestedImpl extends OAuthAccessTokenListFluentImpl> implements KubeSchemaFluent.OAuthAccessTokenListNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAccessTokenListBuilder builder;
    
            OAuthAccessTokenListNestedImpl(OAuthAccessTokenList item){
                    this.builder = new OAuthAccessTokenListBuilder(this, item);
            }
            OAuthAccessTokenListNestedImpl(){
                    this.builder = new OAuthAccessTokenListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthAccessTokenList(builder.build());
    }
    public N endOAuthAccessTokenList(){
            return and();
    }

}
    public class OAuthAuthorizeTokenNestedImpl extends OAuthAuthorizeTokenFluentImpl> implements KubeSchemaFluent.OAuthAuthorizeTokenNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAuthorizeTokenBuilder builder;
    
            OAuthAuthorizeTokenNestedImpl(OAuthAuthorizeToken item){
                    this.builder = new OAuthAuthorizeTokenBuilder(this, item);
            }
            OAuthAuthorizeTokenNestedImpl(){
                    this.builder = new OAuthAuthorizeTokenBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthAuthorizeToken(builder.build());
    }
    public N endOAuthAuthorizeToken(){
            return and();
    }

}
    public class OAuthAuthorizeTokenListNestedImpl extends OAuthAuthorizeTokenListFluentImpl> implements KubeSchemaFluent.OAuthAuthorizeTokenListNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthAuthorizeTokenListBuilder builder;
    
            OAuthAuthorizeTokenListNestedImpl(OAuthAuthorizeTokenList item){
                    this.builder = new OAuthAuthorizeTokenListBuilder(this, item);
            }
            OAuthAuthorizeTokenListNestedImpl(){
                    this.builder = new OAuthAuthorizeTokenListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthAuthorizeTokenList(builder.build());
    }
    public N endOAuthAuthorizeTokenList(){
            return and();
    }

}
    public class OAuthClientNestedImpl extends OAuthClientFluentImpl> implements KubeSchemaFluent.OAuthClientNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientBuilder builder;
    
            OAuthClientNestedImpl(OAuthClient item){
                    this.builder = new OAuthClientBuilder(this, item);
            }
            OAuthClientNestedImpl(){
                    this.builder = new OAuthClientBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthClient(builder.build());
    }
    public N endOAuthClient(){
            return and();
    }

}
    public class OAuthClientAuthorizationNestedImpl extends OAuthClientAuthorizationFluentImpl> implements KubeSchemaFluent.OAuthClientAuthorizationNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientAuthorizationBuilder builder;
    
            OAuthClientAuthorizationNestedImpl(OAuthClientAuthorization item){
                    this.builder = new OAuthClientAuthorizationBuilder(this, item);
            }
            OAuthClientAuthorizationNestedImpl(){
                    this.builder = new OAuthClientAuthorizationBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthClientAuthorization(builder.build());
    }
    public N endOAuthClientAuthorization(){
            return and();
    }

}
    public class OAuthClientAuthorizationListNestedImpl extends OAuthClientAuthorizationListFluentImpl> implements KubeSchemaFluent.OAuthClientAuthorizationListNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientAuthorizationListBuilder builder;
    
            OAuthClientAuthorizationListNestedImpl(OAuthClientAuthorizationList item){
                    this.builder = new OAuthClientAuthorizationListBuilder(this, item);
            }
            OAuthClientAuthorizationListNestedImpl(){
                    this.builder = new OAuthClientAuthorizationListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthClientAuthorizationList(builder.build());
    }
    public N endOAuthClientAuthorizationList(){
            return and();
    }

}
    public class OAuthClientListNestedImpl extends OAuthClientListFluentImpl> implements KubeSchemaFluent.OAuthClientListNested,io.alauda.kubernetes.api.builder.Nested{

            private final OAuthClientListBuilder builder;
    
            OAuthClientListNestedImpl(OAuthClientList item){
                    this.builder = new OAuthClientListBuilder(this, item);
            }
            OAuthClientListNestedImpl(){
                    this.builder = new OAuthClientListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withOAuthClientList(builder.build());
    }
    public N endOAuthClientList(){
            return and();
    }

}
    public class ObjectMetaNestedImpl extends ObjectMetaFluentImpl> implements KubeSchemaFluent.ObjectMetaNested,io.alauda.kubernetes.api.builder.Nested{

            private final ObjectMetaBuilder builder;
    
            ObjectMetaNestedImpl(ObjectMeta item){
                    this.builder = new ObjectMetaBuilder(this, item);
            }
            ObjectMetaNestedImpl(){
                    this.builder = new ObjectMetaBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withObjectMeta(builder.build());
    }
    public N endObjectMeta(){
            return and();
    }

}
    public class PatchNestedImpl extends PatchFluentImpl> implements KubeSchemaFluent.PatchNested,io.alauda.kubernetes.api.builder.Nested{

            private final PatchBuilder builder;
    
            PatchNestedImpl(Patch item){
                    this.builder = new PatchBuilder(this, item);
            }
            PatchNestedImpl(){
                    this.builder = new PatchBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPatch(builder.build());
    }
    public N endPatch(){
            return and();
    }

}
    public class PersistentVolumeNestedImpl extends PersistentVolumeFluentImpl> implements KubeSchemaFluent.PersistentVolumeNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeBuilder builder;
    
            PersistentVolumeNestedImpl(PersistentVolume item){
                    this.builder = new PersistentVolumeBuilder(this, item);
            }
            PersistentVolumeNestedImpl(){
                    this.builder = new PersistentVolumeBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPersistentVolume(builder.build());
    }
    public N endPersistentVolume(){
            return and();
    }

}
    public class PersistentVolumeClaimNestedImpl extends PersistentVolumeClaimFluentImpl> implements KubeSchemaFluent.PersistentVolumeClaimNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimBuilder builder;
    
            PersistentVolumeClaimNestedImpl(PersistentVolumeClaim item){
                    this.builder = new PersistentVolumeClaimBuilder(this, item);
            }
            PersistentVolumeClaimNestedImpl(){
                    this.builder = new PersistentVolumeClaimBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPersistentVolumeClaim(builder.build());
    }
    public N endPersistentVolumeClaim(){
            return and();
    }

}
    public class PersistentVolumeClaimListNestedImpl extends PersistentVolumeClaimListFluentImpl> implements KubeSchemaFluent.PersistentVolumeClaimListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimListBuilder builder;
    
            PersistentVolumeClaimListNestedImpl(PersistentVolumeClaimList item){
                    this.builder = new PersistentVolumeClaimListBuilder(this, item);
            }
            PersistentVolumeClaimListNestedImpl(){
                    this.builder = new PersistentVolumeClaimListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPersistentVolumeClaimList(builder.build());
    }
    public N endPersistentVolumeClaimList(){
            return and();
    }

}
    public class PersistentVolumeListNestedImpl extends PersistentVolumeListFluentImpl> implements KubeSchemaFluent.PersistentVolumeListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeListBuilder builder;
    
            PersistentVolumeListNestedImpl(PersistentVolumeList item){
                    this.builder = new PersistentVolumeListBuilder(this, item);
            }
            PersistentVolumeListNestedImpl(){
                    this.builder = new PersistentVolumeListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPersistentVolumeList(builder.build());
    }
    public N endPersistentVolumeList(){
            return and();
    }

}
    public class PipelineNestedImpl extends PipelineFluentImpl> implements KubeSchemaFluent.PipelineNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineBuilder builder;
    
            PipelineNestedImpl(Pipeline item){
                    this.builder = new PipelineBuilder(this, item);
            }
            PipelineNestedImpl(){
                    this.builder = new PipelineBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPipeline(builder.build());
    }
    public N endPipeline(){
            return and();
    }

}
    public class PipelineConfigNestedImpl extends PipelineConfigFluentImpl> implements KubeSchemaFluent.PipelineConfigNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigBuilder builder;
    
            PipelineConfigNestedImpl(PipelineConfig item){
                    this.builder = new PipelineConfigBuilder(this, item);
            }
            PipelineConfigNestedImpl(){
                    this.builder = new PipelineConfigBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPipelineConfig(builder.build());
    }
    public N endPipelineConfig(){
            return and();
    }

}
    public class PipelineConfigListNestedImpl extends PipelineConfigListFluentImpl> implements KubeSchemaFluent.PipelineConfigListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigListBuilder builder;
    
            PipelineConfigListNestedImpl(PipelineConfigList item){
                    this.builder = new PipelineConfigListBuilder(this, item);
            }
            PipelineConfigListNestedImpl(){
                    this.builder = new PipelineConfigListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPipelineConfigList(builder.build());
    }
    public N endPipelineConfigList(){
            return and();
    }

}
    public class PipelineListNestedImpl extends PipelineListFluentImpl> implements KubeSchemaFluent.PipelineListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineListBuilder builder;
    
            PipelineListNestedImpl(PipelineList item){
                    this.builder = new PipelineListBuilder(this, item);
            }
            PipelineListNestedImpl(){
                    this.builder = new PipelineListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPipelineList(builder.build());
    }
    public N endPipelineList(){
            return and();
    }

}
    public class PodDisruptionBudgetNestedImpl extends PodDisruptionBudgetFluentImpl> implements KubeSchemaFluent.PodDisruptionBudgetNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetBuilder builder;
    
            PodDisruptionBudgetNestedImpl(PodDisruptionBudget item){
                    this.builder = new PodDisruptionBudgetBuilder(this, item);
            }
            PodDisruptionBudgetNestedImpl(){
                    this.builder = new PodDisruptionBudgetBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPodDisruptionBudget(builder.build());
    }
    public N endPodDisruptionBudget(){
            return and();
    }

}
    public class PodDisruptionBudgetListNestedImpl extends PodDisruptionBudgetListFluentImpl> implements KubeSchemaFluent.PodDisruptionBudgetListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetListBuilder builder;
    
            PodDisruptionBudgetListNestedImpl(PodDisruptionBudgetList item){
                    this.builder = new PodDisruptionBudgetListBuilder(this, item);
            }
            PodDisruptionBudgetListNestedImpl(){
                    this.builder = new PodDisruptionBudgetListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPodDisruptionBudgetList(builder.build());
    }
    public N endPodDisruptionBudgetList(){
            return and();
    }

}
    public class PodListNestedImpl extends PodListFluentImpl> implements KubeSchemaFluent.PodListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodListBuilder builder;
    
            PodListNestedImpl(PodList item){
                    this.builder = new PodListBuilder(this, item);
            }
            PodListNestedImpl(){
                    this.builder = new PodListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPodList(builder.build());
    }
    public N endPodList(){
            return and();
    }

}
    public class PodSecurityPolicyNestedImpl extends PodSecurityPolicyFluentImpl> implements KubeSchemaFluent.PodSecurityPolicyNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyBuilder builder;
    
            PodSecurityPolicyNestedImpl(PodSecurityPolicy item){
                    this.builder = new PodSecurityPolicyBuilder(this, item);
            }
            PodSecurityPolicyNestedImpl(){
                    this.builder = new PodSecurityPolicyBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPodSecurityPolicy(builder.build());
    }
    public N endPodSecurityPolicy(){
            return and();
    }

}
    public class PodSecurityPolicyListNestedImpl extends PodSecurityPolicyListFluentImpl> implements KubeSchemaFluent.PodSecurityPolicyListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyListBuilder builder;
    
            PodSecurityPolicyListNestedImpl(PodSecurityPolicyList item){
                    this.builder = new PodSecurityPolicyListBuilder(this, item);
            }
            PodSecurityPolicyListNestedImpl(){
                    this.builder = new PodSecurityPolicyListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPodSecurityPolicyList(builder.build());
    }
    public N endPodSecurityPolicyList(){
            return and();
    }

}
    public class PodTemplateListNestedImpl extends PodTemplateListFluentImpl> implements KubeSchemaFluent.PodTemplateListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateListBuilder builder;
    
            PodTemplateListNestedImpl(PodTemplateList item){
                    this.builder = new PodTemplateListBuilder(this, item);
            }
            PodTemplateListNestedImpl(){
                    this.builder = new PodTemplateListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPodTemplateList(builder.build());
    }
    public N endPodTemplateList(){
            return and();
    }

}
    public class PolicyNestedImpl extends PolicyFluentImpl> implements KubeSchemaFluent.PolicyNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBuilder builder;
    
            PolicyNestedImpl(Policy item){
                    this.builder = new PolicyBuilder(this, item);
            }
            PolicyNestedImpl(){
                    this.builder = new PolicyBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPolicy(builder.build());
    }
    public N endPolicy(){
            return and();
    }

}
    public class PolicyBindingNestedImpl extends PolicyBindingFluentImpl> implements KubeSchemaFluent.PolicyBindingNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBindingBuilder builder;
    
            PolicyBindingNestedImpl(PolicyBinding item){
                    this.builder = new PolicyBindingBuilder(this, item);
            }
            PolicyBindingNestedImpl(){
                    this.builder = new PolicyBindingBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPolicyBinding(builder.build());
    }
    public N endPolicyBinding(){
            return and();
    }

}
    public class PolicyBindingListNestedImpl extends PolicyBindingListFluentImpl> implements KubeSchemaFluent.PolicyBindingListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyBindingListBuilder builder;
    
            PolicyBindingListNestedImpl(PolicyBindingList item){
                    this.builder = new PolicyBindingListBuilder(this, item);
            }
            PolicyBindingListNestedImpl(){
                    this.builder = new PolicyBindingListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPolicyBindingList(builder.build());
    }
    public N endPolicyBindingList(){
            return and();
    }

}
    public class PolicyListNestedImpl extends PolicyListFluentImpl> implements KubeSchemaFluent.PolicyListNested,io.alauda.kubernetes.api.builder.Nested{

            private final PolicyListBuilder builder;
    
            PolicyListNestedImpl(PolicyList item){
                    this.builder = new PolicyListBuilder(this, item);
            }
            PolicyListNestedImpl(){
                    this.builder = new PolicyListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withPolicyList(builder.build());
    }
    public N endPolicyList(){
            return and();
    }

}
    public class ProjectNestedImpl extends ProjectFluentImpl> implements KubeSchemaFluent.ProjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectBuilder builder;
    
            ProjectNestedImpl(Project item){
                    this.builder = new ProjectBuilder(this, item);
            }
            ProjectNestedImpl(){
                    this.builder = new ProjectBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withProject(builder.build());
    }
    public N endProject(){
            return and();
    }

}
    public class ProjectListNestedImpl extends ProjectListFluentImpl> implements KubeSchemaFluent.ProjectListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectListBuilder builder;
    
            ProjectListNestedImpl(ProjectList item){
                    this.builder = new ProjectListBuilder(this, item);
            }
            ProjectListNestedImpl(){
                    this.builder = new ProjectListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withProjectList(builder.build());
    }
    public N endProjectList(){
            return and();
    }

}
    public class QuantityNestedImpl extends QuantityFluentImpl> implements KubeSchemaFluent.QuantityNested,io.alauda.kubernetes.api.builder.Nested{

            private final QuantityBuilder builder;
    
            QuantityNestedImpl(Quantity item){
                    this.builder = new QuantityBuilder(this, item);
            }
            QuantityNestedImpl(){
                    this.builder = new QuantityBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withQuantity(builder.build());
    }
    public N endQuantity(){
            return and();
    }

}
    public class ReplicaSetNestedImpl extends ReplicaSetFluentImpl> implements KubeSchemaFluent.ReplicaSetNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetBuilder builder;
    
            ReplicaSetNestedImpl(ReplicaSet item){
                    this.builder = new ReplicaSetBuilder(this, item);
            }
            ReplicaSetNestedImpl(){
                    this.builder = new ReplicaSetBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withReplicaSet(builder.build());
    }
    public N endReplicaSet(){
            return and();
    }

}
    public class ReplicaSetListNestedImpl extends ReplicaSetListFluentImpl> implements KubeSchemaFluent.ReplicaSetListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetListBuilder builder;
    
            ReplicaSetListNestedImpl(ReplicaSetList item){
                    this.builder = new ReplicaSetListBuilder(this, item);
            }
            ReplicaSetListNestedImpl(){
                    this.builder = new ReplicaSetListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withReplicaSetList(builder.build());
    }
    public N endReplicaSetList(){
            return and();
    }

}
    public class ReplicationControllerListNestedImpl extends ReplicationControllerListFluentImpl> implements KubeSchemaFluent.ReplicationControllerListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerListBuilder builder;
    
            ReplicationControllerListNestedImpl(ReplicationControllerList item){
                    this.builder = new ReplicationControllerListBuilder(this, item);
            }
            ReplicationControllerListNestedImpl(){
                    this.builder = new ReplicationControllerListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withReplicationControllerList(builder.build());
    }
    public N endReplicationControllerList(){
            return and();
    }

}
    public class ResourceQuotaNestedImpl extends ResourceQuotaFluentImpl> implements KubeSchemaFluent.ResourceQuotaNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaBuilder builder;
    
            ResourceQuotaNestedImpl(ResourceQuota item){
                    this.builder = new ResourceQuotaBuilder(this, item);
            }
            ResourceQuotaNestedImpl(){
                    this.builder = new ResourceQuotaBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withResourceQuota(builder.build());
    }
    public N endResourceQuota(){
            return and();
    }

}
    public class ResourceQuotaListNestedImpl extends ResourceQuotaListFluentImpl> implements KubeSchemaFluent.ResourceQuotaListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaListBuilder builder;
    
            ResourceQuotaListNestedImpl(ResourceQuotaList item){
                    this.builder = new ResourceQuotaListBuilder(this, item);
            }
            ResourceQuotaListNestedImpl(){
                    this.builder = new ResourceQuotaListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withResourceQuotaList(builder.build());
    }
    public N endResourceQuotaList(){
            return and();
    }

}
    public class RoleNestedImpl extends RoleFluentImpl> implements KubeSchemaFluent.RoleNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBuilder builder;
    
            RoleNestedImpl(Role item){
                    this.builder = new RoleBuilder(this, item);
            }
            RoleNestedImpl(){
                    this.builder = new RoleBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRole(builder.build());
    }
    public N endRole(){
            return and();
    }

}
    public class RoleBindingNestedImpl extends RoleBindingFluentImpl> implements KubeSchemaFluent.RoleBindingNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingBuilder builder;
    
            RoleBindingNestedImpl(RoleBinding item){
                    this.builder = new RoleBindingBuilder(this, item);
            }
            RoleBindingNestedImpl(){
                    this.builder = new RoleBindingBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRoleBinding(builder.build());
    }
    public N endRoleBinding(){
            return and();
    }

}
    public class RoleBindingListNestedImpl extends RoleBindingListFluentImpl> implements KubeSchemaFluent.RoleBindingListNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingListBuilder builder;
    
            RoleBindingListNestedImpl(RoleBindingList item){
                    this.builder = new RoleBindingListBuilder(this, item);
            }
            RoleBindingListNestedImpl(){
                    this.builder = new RoleBindingListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRoleBindingList(builder.build());
    }
    public N endRoleBindingList(){
            return and();
    }

}
    public class RoleBindingRestrictionNestedImpl extends RoleBindingRestrictionFluentImpl> implements KubeSchemaFluent.RoleBindingRestrictionNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleBindingRestrictionBuilder builder;
    
            RoleBindingRestrictionNestedImpl(RoleBindingRestriction item){
                    this.builder = new RoleBindingRestrictionBuilder(this, item);
            }
            RoleBindingRestrictionNestedImpl(){
                    this.builder = new RoleBindingRestrictionBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRoleBindingRestriction(builder.build());
    }
    public N endRoleBindingRestriction(){
            return and();
    }

}
    public class RoleListNestedImpl extends RoleListFluentImpl> implements KubeSchemaFluent.RoleListNested,io.alauda.kubernetes.api.builder.Nested{

            private final RoleListBuilder builder;
    
            RoleListNestedImpl(RoleList item){
                    this.builder = new RoleListBuilder(this, item);
            }
            RoleListNestedImpl(){
                    this.builder = new RoleListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRoleList(builder.build());
    }
    public N endRoleList(){
            return and();
    }

}
    public class RootPathsNestedImpl extends RootPathsFluentImpl> implements KubeSchemaFluent.RootPathsNested,io.alauda.kubernetes.api.builder.Nested{

            private final RootPathsBuilder builder;
    
            RootPathsNestedImpl(RootPaths item){
                    this.builder = new RootPathsBuilder(this, item);
            }
            RootPathsNestedImpl(){
                    this.builder = new RootPathsBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRootPaths(builder.build());
    }
    public N endRootPaths(){
            return and();
    }

}
    public class RouteNestedImpl extends RouteFluentImpl> implements KubeSchemaFluent.RouteNested,io.alauda.kubernetes.api.builder.Nested{

            private final RouteBuilder builder;
    
            RouteNestedImpl(Route item){
                    this.builder = new RouteBuilder(this, item);
            }
            RouteNestedImpl(){
                    this.builder = new RouteBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRoute(builder.build());
    }
    public N endRoute(){
            return and();
    }

}
    public class RouteListNestedImpl extends RouteListFluentImpl> implements KubeSchemaFluent.RouteListNested,io.alauda.kubernetes.api.builder.Nested{

            private final RouteListBuilder builder;
    
            RouteListNestedImpl(RouteList item){
                    this.builder = new RouteListBuilder(this, item);
            }
            RouteListNestedImpl(){
                    this.builder = new RouteListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withRouteList(builder.build());
    }
    public N endRouteList(){
            return and();
    }

}
    public class ScaleNestedImpl extends ScaleFluentImpl> implements KubeSchemaFluent.ScaleNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleBuilder builder;
    
            ScaleNestedImpl(Scale item){
                    this.builder = new ScaleBuilder(this, item);
            }
            ScaleNestedImpl(){
                    this.builder = new ScaleBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withScale(builder.build());
    }
    public N endScale(){
            return and();
    }

}
    public class SecretNestedImpl extends SecretFluentImpl> implements KubeSchemaFluent.SecretNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretBuilder builder;
    
            SecretNestedImpl(Secret item){
                    this.builder = new SecretBuilder(this, item);
            }
            SecretNestedImpl(){
                    this.builder = new SecretBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withSecret(builder.build());
    }
    public N endSecret(){
            return and();
    }

}
    public class SecretListNestedImpl extends SecretListFluentImpl> implements KubeSchemaFluent.SecretListNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretListBuilder builder;
    
            SecretListNestedImpl(SecretList item){
                    this.builder = new SecretListBuilder(this, item);
            }
            SecretListNestedImpl(){
                    this.builder = new SecretListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withSecretList(builder.build());
    }
    public N endSecretList(){
            return and();
    }

}
    public class SecurityContextConstraintsNestedImpl extends SecurityContextConstraintsFluentImpl> implements KubeSchemaFluent.SecurityContextConstraintsNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecurityContextConstraintsBuilder builder;
    
            SecurityContextConstraintsNestedImpl(SecurityContextConstraints item){
                    this.builder = new SecurityContextConstraintsBuilder(this, item);
            }
            SecurityContextConstraintsNestedImpl(){
                    this.builder = new SecurityContextConstraintsBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withSecurityContextConstraints(builder.build());
    }
    public N endSecurityContextConstraints(){
            return and();
    }

}
    public class SecurityContextConstraintsListNestedImpl extends SecurityContextConstraintsListFluentImpl> implements KubeSchemaFluent.SecurityContextConstraintsListNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecurityContextConstraintsListBuilder builder;
    
            SecurityContextConstraintsListNestedImpl(SecurityContextConstraintsList item){
                    this.builder = new SecurityContextConstraintsListBuilder(this, item);
            }
            SecurityContextConstraintsListNestedImpl(){
                    this.builder = new SecurityContextConstraintsListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withSecurityContextConstraintsList(builder.build());
    }
    public N endSecurityContextConstraintsList(){
            return and();
    }

}
    public class ServiceAccountNestedImpl extends ServiceAccountFluentImpl> implements KubeSchemaFluent.ServiceAccountNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountBuilder builder;
    
            ServiceAccountNestedImpl(ServiceAccount item){
                    this.builder = new ServiceAccountBuilder(this, item);
            }
            ServiceAccountNestedImpl(){
                    this.builder = new ServiceAccountBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withServiceAccount(builder.build());
    }
    public N endServiceAccount(){
            return and();
    }

}
    public class ServiceAccountListNestedImpl extends ServiceAccountListFluentImpl> implements KubeSchemaFluent.ServiceAccountListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountListBuilder builder;
    
            ServiceAccountListNestedImpl(ServiceAccountList item){
                    this.builder = new ServiceAccountListBuilder(this, item);
            }
            ServiceAccountListNestedImpl(){
                    this.builder = new ServiceAccountListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withServiceAccountList(builder.build());
    }
    public N endServiceAccountList(){
            return and();
    }

}
    public class ServiceListNestedImpl extends ServiceListFluentImpl> implements KubeSchemaFluent.ServiceListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceListBuilder builder;
    
            ServiceListNestedImpl(ServiceList item){
                    this.builder = new ServiceListBuilder(this, item);
            }
            ServiceListNestedImpl(){
                    this.builder = new ServiceListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withServiceList(builder.build());
    }
    public N endServiceList(){
            return and();
    }

}
    public class StatefulSetNestedImpl extends StatefulSetFluentImpl> implements KubeSchemaFluent.StatefulSetNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetBuilder builder;
    
            StatefulSetNestedImpl(StatefulSet item){
                    this.builder = new StatefulSetBuilder(this, item);
            }
            StatefulSetNestedImpl(){
                    this.builder = new StatefulSetBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withStatefulSet(builder.build());
    }
    public N endStatefulSet(){
            return and();
    }

}
    public class StatefulSetListNestedImpl extends StatefulSetListFluentImpl> implements KubeSchemaFluent.StatefulSetListNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetListBuilder builder;
    
            StatefulSetListNestedImpl(StatefulSetList item){
                    this.builder = new StatefulSetListBuilder(this, item);
            }
            StatefulSetListNestedImpl(){
                    this.builder = new StatefulSetListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withStatefulSetList(builder.build());
    }
    public N endStatefulSetList(){
            return and();
    }

}
    public class StatusNestedImpl extends StatusFluentImpl> implements KubeSchemaFluent.StatusNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatusBuilder builder;
    
            StatusNestedImpl(Status item){
                    this.builder = new StatusBuilder(this, item);
            }
            StatusNestedImpl(){
                    this.builder = new StatusBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withStatus(builder.build());
    }
    public N endStatus(){
            return and();
    }

}
    public class StorageClassNestedImpl extends StorageClassFluentImpl> implements KubeSchemaFluent.StorageClassNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassBuilder builder;
    
            StorageClassNestedImpl(StorageClass item){
                    this.builder = new StorageClassBuilder(this, item);
            }
            StorageClassNestedImpl(){
                    this.builder = new StorageClassBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withStorageClass(builder.build());
    }
    public N endStorageClass(){
            return and();
    }

}
    public class StorageClassListNestedImpl extends StorageClassListFluentImpl> implements KubeSchemaFluent.StorageClassListNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassListBuilder builder;
    
            StorageClassListNestedImpl(StorageClassList item){
                    this.builder = new StorageClassListBuilder(this, item);
            }
            StorageClassListNestedImpl(){
                    this.builder = new StorageClassListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withStorageClassList(builder.build());
    }
    public N endStorageClassList(){
            return and();
    }

}
    public class SubjectAccessReviewNestedImpl extends SubjectAccessReviewFluentImpl> implements KubeSchemaFluent.SubjectAccessReviewNested,io.alauda.kubernetes.api.builder.Nested{

            private final SubjectAccessReviewBuilder builder;
    
            SubjectAccessReviewNestedImpl(SubjectAccessReview item){
                    this.builder = new SubjectAccessReviewBuilder(this, item);
            }
            SubjectAccessReviewNestedImpl(){
                    this.builder = new SubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withSubjectAccessReview(builder.build());
    }
    public N endSubjectAccessReview(){
            return and();
    }

}
    public class SubjectAccessReviewResponseNestedImpl extends SubjectAccessReviewResponseFluentImpl> implements KubeSchemaFluent.SubjectAccessReviewResponseNested,io.alauda.kubernetes.api.builder.Nested{

            private final SubjectAccessReviewResponseBuilder builder;
    
            SubjectAccessReviewResponseNestedImpl(SubjectAccessReviewResponse item){
                    this.builder = new SubjectAccessReviewResponseBuilder(this, item);
            }
            SubjectAccessReviewResponseNestedImpl(){
                    this.builder = new SubjectAccessReviewResponseBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withSubjectAccessReviewResponse(builder.build());
    }
    public N endSubjectAccessReviewResponse(){
            return and();
    }

}
    public class TagEventNestedImpl extends TagEventFluentImpl> implements KubeSchemaFluent.TagEventNested,io.alauda.kubernetes.api.builder.Nested{

            private final TagEventBuilder builder;
    
            TagEventNestedImpl(TagEvent item){
                    this.builder = new TagEventBuilder(this, item);
            }
            TagEventNestedImpl(){
                    this.builder = new TagEventBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withTagEvent(builder.build());
    }
    public N endTagEvent(){
            return and();
    }

}
    public class TemplateNestedImpl extends TemplateFluentImpl> implements KubeSchemaFluent.TemplateNested,io.alauda.kubernetes.api.builder.Nested{

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

}
    public class TemplateListNestedImpl extends TemplateListFluentImpl> implements KubeSchemaFluent.TemplateListNested,io.alauda.kubernetes.api.builder.Nested{

            private final TemplateListBuilder builder;
    
            TemplateListNestedImpl(TemplateList item){
                    this.builder = new TemplateListBuilder(this, item);
            }
            TemplateListNestedImpl(){
                    this.builder = new TemplateListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withTemplateList(builder.build());
    }
    public N endTemplateList(){
            return and();
    }

}
    public class ThirdPartyResourceNestedImpl extends ThirdPartyResourceFluentImpl> implements KubeSchemaFluent.ThirdPartyResourceNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceBuilder builder;
    
            ThirdPartyResourceNestedImpl(ThirdPartyResource item){
                    this.builder = new ThirdPartyResourceBuilder(this, item);
            }
            ThirdPartyResourceNestedImpl(){
                    this.builder = new ThirdPartyResourceBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withThirdPartyResource(builder.build());
    }
    public N endThirdPartyResource(){
            return and();
    }

}
    public class ThirdPartyResourceListNestedImpl extends ThirdPartyResourceListFluentImpl> implements KubeSchemaFluent.ThirdPartyResourceListNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceListBuilder builder;
    
            ThirdPartyResourceListNestedImpl(ThirdPartyResourceList item){
                    this.builder = new ThirdPartyResourceListBuilder(this, item);
            }
            ThirdPartyResourceListNestedImpl(){
                    this.builder = new ThirdPartyResourceListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withThirdPartyResourceList(builder.build());
    }
    public N endThirdPartyResourceList(){
            return and();
    }

}
    public class TokenReviewNestedImpl extends TokenReviewFluentImpl> implements KubeSchemaFluent.TokenReviewNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewBuilder builder;
    
            TokenReviewNestedImpl(TokenReview item){
                    this.builder = new TokenReviewBuilder(this, item);
            }
            TokenReviewNestedImpl(){
                    this.builder = new TokenReviewBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withTokenReview(builder.build());
    }
    public N endTokenReview(){
            return and();
    }

}
    public class TolerationNestedImpl extends TolerationFluentImpl> implements KubeSchemaFluent.TolerationNested,io.alauda.kubernetes.api.builder.Nested{

            private final TolerationBuilder builder;
    
            TolerationNestedImpl(Toleration item){
                    this.builder = new TolerationBuilder(this, item);
            }
            TolerationNestedImpl(){
                    this.builder = new TolerationBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withToleration(builder.build());
    }
    public N endToleration(){
            return and();
    }

}
    public class UserNestedImpl extends UserFluentImpl> implements KubeSchemaFluent.UserNested,io.alauda.kubernetes.api.builder.Nested{

            private final UserBuilder builder;
    
            UserNestedImpl(User item){
                    this.builder = new UserBuilder(this, item);
            }
            UserNestedImpl(){
                    this.builder = new UserBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withUser(builder.build());
    }
    public N endUser(){
            return and();
    }

}
    public class UserListNestedImpl extends UserListFluentImpl> implements KubeSchemaFluent.UserListNested,io.alauda.kubernetes.api.builder.Nested{

            private final UserListBuilder builder;
    
            UserListNestedImpl(UserList item){
                    this.builder = new UserListBuilder(this, item);
            }
            UserListNestedImpl(){
                    this.builder = new UserListBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withUserList(builder.build());
    }
    public N endUserList(){
            return and();
    }

}
    public class WatchEventNestedImpl extends WatchEventFluentImpl> implements KubeSchemaFluent.WatchEventNested,io.alauda.kubernetes.api.builder.Nested{

            private final WatchEventBuilder builder;
    
            WatchEventNestedImpl(WatchEvent item){
                    this.builder = new WatchEventBuilder(this, item);
            }
            WatchEventNestedImpl(){
                    this.builder = new WatchEventBuilder(this);
            }
    
    public N and(){
            return (N) KubeSchemaFluentImpl.this.withWatchEvent(builder.build());
    }
    public N endWatchEvent(){
            return and();
    }

}


}