annotations.io.alauda.kubernetes.api.model.WatchEventFluentImpl Maven / Gradle / Ivy

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

import io.alauda.kubernetes.api.model.extensions.ReplicaSetCondition;
import io.alauda.kubernetes.api.model.authorization.ResourceAttributes;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionCondition;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyList;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetUpdateStrategyBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewStatusFluentImpl;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewStatusBuilder;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDeploymentFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicy;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatusFluentImpl;
import io.alauda.kubernetes.api.model.version.InfoBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyListBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReview;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetConditionFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ScaleSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.RollbackConfigBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressStatus;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressRuleValueFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressTLSFluentImpl;
import io.alauda.kubernetes.api.model.extensions.KubernetesRunAsUserStrategyOptions;
import io.alauda.kubernetes.api.model.authorization.ResourceAttributesBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentStrategyBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReviewStatus;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetStatus;
import io.alauda.kubernetes.api.model.authentication.TokenReviewSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressListBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicySpecBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSet;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressRule;
import java.lang.Boolean;
import java.lang.Object;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetSpecFluentImpl;
import io.alauda.kubernetes.api.builder.VisitableBuilder;
import io.alauda.kubernetes.api.model.extensions.FSGroupStrategyOptions;
import io.alauda.kubernetes.api.model.extensions.IDRangeFluentImpl;
import io.alauda.kubernetes.api.model.extensions.FSGroupStrategyOptionsFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressSpec;
import io.alauda.kubernetes.api.model.extensions.DeploymentList;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceList;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPortFluentImpl;
import io.alauda.kubernetes.api.model.authentication.TokenReviewStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateStatefulSetStrategyFluentImpl;
import java.lang.Deprecated;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetStatusFluentImpl;
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.SELinuxStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.authentication.UserInfoBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetSpec;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewSpec;
import io.alauda.kubernetes.api.model.authentication.TokenReviewSpec;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionConditionBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetList;
import io.alauda.kubernetes.api.model.authentication.UserInfoFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSetSpecBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNamesFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpec;
import io.alauda.kubernetes.api.model.authentication.TokenReviewBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentStatus;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetBuilder;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetSpec;
import io.alauda.kubernetes.api.model.extensions.FSGroupStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetUpdateStrategyFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentStrategyFluentImpl;
import io.alauda.kubernetes.api.model.extensions.APIVersionBuilder;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetStatus;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinition;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDaemonSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ScaleSpecBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.IDRange;
import io.alauda.kubernetes.api.model.extensions.HostPortRangeBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentCondition;
import io.alauda.kubernetes.api.model.extensions.APIVersionFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetConditionBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetUpdateStrategy;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPeer;
import io.alauda.kubernetes.api.model.extensions.DaemonSetSpec;
import io.alauda.kubernetes.api.model.extensions.StatefulSetListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSetListBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicySpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressPathBuilder;
import io.alauda.kubernetes.api.model.extensions.ScaleSpec;
import io.alauda.kubernetes.api.model.extensions.DeploymentStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.ScaleBuilder;
import io.alauda.kubernetes.api.builder.Nested;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressPath;
import java.lang.String;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetListBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatusBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewStatus;
import io.alauda.kubernetes.api.model.extensions.HostPortRange;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetList;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicy;
import io.alauda.kubernetes.api.model.extensions.DaemonSetStatus;
import io.alauda.kubernetes.api.model.extensions.IngressBackendBuilder;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyIngressRuleBuilder;
import io.alauda.kubernetes.api.model.extensions.ScaleFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressRuleFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetListBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetSpecBuilder;
import io.alauda.kubernetes.api.model.authentication.UserInfo;
import io.alauda.kubernetes.api.model.version.Info;
import io.alauda.kubernetes.api.model.extensions.DaemonSetSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicySpec;
import io.alauda.kubernetes.api.model.extensions.RollbackConfig;
import io.alauda.kubernetes.api.model.extensions.IngressListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressRuleBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetStatusBuilder;
import io.alauda.kubernetes.api.model.authorization.ResourceAttributesFluentImpl;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDaemonSet;
import io.alauda.kubernetes.api.model.extensions.StatefulSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollback;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPeerFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyIngressRuleFluentImpl;
import io.alauda.kubernetes.api.model.extensions.APIVersion;
import io.alauda.kubernetes.api.model.extensions.DeploymentSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateStatefulSetStrategy;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateStatefulSetStrategyBuilder;
import io.alauda.kubernetes.api.model.extensions.SupplementalGroupsStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetUpdateStrategyFluentImpl;
import io.alauda.kubernetes.api.model.extensions.SELinuxStrategyOptions;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewFluentImpl;
import io.alauda.kubernetes.api.model.authentication.TokenReviewStatusFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionConditionFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.KubernetesRunAsUserStrategyOptionsFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentSpec;
import java.lang.Long;
import io.alauda.kubernetes.api.model.extensions.StatefulSetStatus;
import io.alauda.kubernetes.api.model.authorization.NonResourceAttributesBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetListBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicySpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyListBuilder;
import io.alauda.kubernetes.api.model.extensions.SupplementalGroupsStrategyOptionsFluentImpl;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDeploymentBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPeerBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetList;
import javax.validation.Valid;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceListBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetUpdateStrategyBuilder;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressRuleValueBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressBackendFluentImpl;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DeploymentFluentImpl;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressRuleValue;
import io.alauda.kubernetes.api.model.extensions.ScaleStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.HostPortRangeFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceListFluentImpl;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNames;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSetSpec;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionList;
import io.alauda.kubernetes.api.model.extensions.Deployment;
import io.alauda.kubernetes.api.model.authorization.NonResourceAttributes;
import io.alauda.kubernetes.api.model.extensions.SELinuxStrategyOptionsFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPort;
import io.alauda.kubernetes.api.model.extensions.IngressList;
import io.alauda.kubernetes.api.model.extensions.StatefulSetSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IDRangeBuilder;
import io.alauda.kubernetes.api.model.extensions.RollbackConfigFluentImpl;
import io.alauda.kubernetes.api.model.extensions.IngressStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDaemonSetBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyIngressRule;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResource;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollbackBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReviewSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressTLS;
import io.alauda.kubernetes.api.model.extensions.IngressBackend;
import io.alauda.kubernetes.api.model.extensions.ScaleStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicySpec;
import io.alauda.kubernetes.api.model.version.InfoFluentImpl;
import io.alauda.kubernetes.api.model.extensions.Ingress;
import io.alauda.kubernetes.api.model.extensions.DaemonSetBuilder;
import io.alauda.kubernetes.api.model.extensions.Scale;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressPathFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentConditionBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentListBuilder;
import io.alauda.kubernetes.api.model.authorization.NonResourceAttributesFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetList;
import io.alauda.kubernetes.api.model.extensions.ReplicaSet;
import io.alauda.kubernetes.api.model.extensions.DeploymentStrategy;
import io.alauda.kubernetes.api.model.extensions.IngressStatusBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReviewFluentImpl;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.KubernetesRunAsUserStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetSpecFluentImpl;
import io.alauda.kubernetes.api.model.extensions.DaemonSetStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPortBuilder;
import java.lang.Integer;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.alauda.kubernetes.api.model.extensions.DeploymentConditionFluentImpl;
import io.alauda.kubernetes.api.builder.BaseFluent;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNamesBuilder;
import io.alauda.kubernetes.api.model.extensions.SupplementalGroupsStrategyOptions;
import io.alauda.kubernetes.api.model.extensions.DaemonSetFluentImpl;
import io.alauda.kubernetes.api.model.extensions.ScaleStatus;
import io.alauda.kubernetes.api.model.extensions.IngressTLSBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetUpdateStrategy;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionListBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewSpecBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatus;
import io.alauda.kubernetes.api.model.extensions.DeploymentStatusFluentImpl;
import io.alauda.kubernetes.api.model.extensions.StatefulSet;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDeployment;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudget;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetListFluentImpl;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicySpecBuilder;

public class WatchEventFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements WatchEventFluent{

    private VisitableBuilder object;
    private String type;

    public WatchEventFluentImpl(){
    }
    public WatchEventFluentImpl(WatchEvent instance){
            this.withObject(instance.getObject()); 
            this.withType(instance.getType()); 
    }

    
/**
 * This method has been deprecated, please use method buildObject instead.
 */
@Deprecated public KubernetesResource getObject(){
            return this.object!=null?this.object.build():null;
    }

    public KubernetesResource buildObject(){
            return this.object!=null?this.object.build():null;
    }

    public A withObject(KubernetesResource object){
            if (object instanceof RepositoryCommit){ this.object= new RepositoryCommitBuilder((RepositoryCommit)object); _visitables.add(this.object);}
            if (object instanceof Affinity){ this.object= new AffinityBuilder((Affinity)object); _visitables.add(this.object);}
            if (object instanceof NamedCluster){ this.object= new NamedClusterBuilder((NamedCluster)object); _visitables.add(this.object);}
            if (object instanceof AWSElasticBlockStoreVolumeSource){ this.object= new AWSElasticBlockStoreVolumeSourceBuilder((AWSElasticBlockStoreVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof Context){ this.object= new ContextBuilder((Context)object); _visitables.add(this.object);}
            if (object instanceof ServicePort){ this.object= new ServicePortBuilder((ServicePort)object); _visitables.add(this.object);}
            if (object instanceof Binding){ this.object= new BindingBuilder((Binding)object); _visitables.add(this.object);}
            if (object instanceof AuthInfo){ this.object= new AuthInfoBuilder((AuthInfo)object); _visitables.add(this.object);}
            if (object instanceof Ingress){ this.object= new IngressBuilder((Ingress)object); _visitables.add(this.object);}
            if (object instanceof ClusterPipelineTaskTemplateList){ this.object= new ClusterPipelineTaskTemplateListBuilder((ClusterPipelineTaskTemplateList)object); _visitables.add(this.object);}
            if (object instanceof RollingUpdateStatefulSetStrategy){ this.object= new RollingUpdateStatefulSetStrategyBuilder((RollingUpdateStatefulSetStrategy)object); _visitables.add(this.object);}
            if (object instanceof LocalSubjectAccessReview){ this.object= new LocalSubjectAccessReviewBuilder((LocalSubjectAccessReview)object); _visitables.add(this.object);}
            if (object instanceof StatefulSet){ this.object= new StatefulSetBuilder((StatefulSet)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskArgumentSchema){ this.object= new PipelineTaskArgumentSchemaBuilder((PipelineTaskArgumentSchema)object); _visitables.add(this.object);}
            if (object instanceof Container){ this.object= new ContainerBuilder((Container)object); _visitables.add(this.object);}
            if (object instanceof ResourceQuotaSpec){ this.object= new ResourceQuotaSpecBuilder((ResourceQuotaSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateTaskInstance){ this.object= new PipelineTemplateTaskInstanceBuilder((PipelineTemplateTaskInstance)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateList){ this.object= new PipelineTemplateListBuilder((PipelineTemplateList)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskOption){ this.object= new PipelineTaskOptionBuilder((PipelineTaskOption)object); _visitables.add(this.object);}
            if (object instanceof JobSpec){ this.object= new JobSpecBuilder((JobSpec)object); _visitables.add(this.object);}
            if (object instanceof SecretList){ this.object= new SecretListBuilder((SecretList)object); _visitables.add(this.object);}
            if (object instanceof JenkinsList){ this.object= new JenkinsListBuilder((JenkinsList)object); _visitables.add(this.object);}
            if (object instanceof LabelSelector){ this.object= new LabelSelectorBuilder((LabelSelector)object); _visitables.add(this.object);}
            if (object instanceof CronJobSpec){ this.object= new CronJobSpecBuilder((CronJobSpec)object); _visitables.add(this.object);}
            if (object instanceof DeleteOptions){ this.object= new DeleteOptionsBuilder((DeleteOptions)object); _visitables.add(this.object);}
            if (object instanceof PipelineTrigger){ this.object= new PipelineTriggerBuilder((PipelineTrigger)object); _visitables.add(this.object);}
            if (object instanceof DeploymentRollback){ this.object= new DeploymentRollbackBuilder((DeploymentRollback)object); _visitables.add(this.object);}
            if (object instanceof SecretVolumeSource){ this.object= new SecretVolumeSourceBuilder((SecretVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof DownwardAPIProjection){ this.object= new DownwardAPIProjectionBuilder((DownwardAPIProjection)object); _visitables.add(this.object);}
            if (object instanceof LoadBalancerIngress){ this.object= new LoadBalancerIngressBuilder((LoadBalancerIngress)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoBindingAccount){ this.object= new CodeRepoBindingAccountBuilder((CodeRepoBindingAccount)object); _visitables.add(this.object);}
            if (object instanceof HorizontalPodAutoscalerSpec){ this.object= new HorizontalPodAutoscalerSpecBuilder((HorizontalPodAutoscalerSpec)object); _visitables.add(this.object);}
            if (object instanceof ProjectNamespaceStatus){ this.object= new ProjectNamespaceStatusBuilder((ProjectNamespaceStatus)object); _visitables.add(this.object);}
            if (object instanceof KubernetesRunAsUserStrategyOptions){ this.object= new KubernetesRunAsUserStrategyOptionsBuilder((KubernetesRunAsUserStrategyOptions)object); _visitables.add(this.object);}
            if (object instanceof StatusDetails){ this.object= new StatusDetailsBuilder((StatusDetails)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskApprove){ this.object= new PipelineTaskApproveBuilder((PipelineTaskApprove)object); _visitables.add(this.object);}
            if (object instanceof PodSecurityPolicy){ this.object= new PodSecurityPolicyBuilder((PodSecurityPolicy)object); _visitables.add(this.object);}
            if (object instanceof WeightedPodAffinityTerm){ this.object= new WeightedPodAffinityTermBuilder((WeightedPodAffinityTerm)object); _visitables.add(this.object);}
            if (object instanceof Pipeline){ this.object= new PipelineBuilder((Pipeline)object); _visitables.add(this.object);}
            if (object instanceof NodeList){ this.object= new NodeListBuilder((NodeList)object); _visitables.add(this.object);}
            if (object instanceof CinderVolumeSource){ this.object= new CinderVolumeSourceBuilder((CinderVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof CustomResourceDefinitionStatus){ this.object= new CustomResourceDefinitionStatusBuilder((CustomResourceDefinitionStatus)object); _visitables.add(this.object);}
            if (object instanceof NetworkPolicySpec){ this.object= new NetworkPolicySpecBuilder((NetworkPolicySpec)object); _visitables.add(this.object);}
            if (object instanceof LocalVolumeSource){ this.object= new LocalVolumeSourceBuilder((LocalVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof ResourceQuota){ this.object= new ResourceQuotaBuilder((ResourceQuota)object); _visitables.add(this.object);}
            if (object instanceof PodList){ this.object= new PodListBuilder((PodList)object); _visitables.add(this.object);}
            if (object instanceof UserInfo){ this.object= new UserInfoBuilder((UserInfo)object); _visitables.add(this.object);}
            if (object instanceof PipelineSourceSvn){ this.object= new PipelineSourceSvnBuilder((PipelineSourceSvn)object); _visitables.add(this.object);}
            if (object instanceof CustomResourceDefinitionSpec){ this.object= new CustomResourceDefinitionSpecBuilder((CustomResourceDefinitionSpec)object); _visitables.add(this.object);}
            if (object instanceof CodeRepositoryStatus){ this.object= new CodeRepositoryStatusBuilder((CodeRepositoryStatus)object); _visitables.add(this.object);}
            if (object instanceof AzureFileVolumeSource){ this.object= new AzureFileVolumeSourceBuilder((AzureFileVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoServiceSpec){ this.object= new CodeRepoServiceSpecBuilder((CodeRepoServiceSpec)object); _visitables.add(this.object);}
            if (object instanceof ServiceAccount){ this.object= new ServiceAccountBuilder((ServiceAccount)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoBindingSpec){ this.object= new CodeRepoBindingSpecBuilder((CodeRepoBindingSpec)object); _visitables.add(this.object);}
            if (object instanceof StorageOSPersistentVolumeSource){ this.object= new StorageOSPersistentVolumeSourceBuilder((StorageOSPersistentVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof LimitRangeSpec){ this.object= new LimitRangeSpecBuilder((LimitRangeSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineStageInstance){ this.object= new PipelineStageInstanceBuilder((PipelineStageInstance)object); _visitables.add(this.object);}
            if (object instanceof ProjectList){ this.object= new ProjectListBuilder((ProjectList)object); _visitables.add(this.object);}
            if (object instanceof ConfigMap){ this.object= new ConfigMapBuilder((ConfigMap)object); _visitables.add(this.object);}
            if (object instanceof PipelineCause){ this.object= new PipelineCauseBuilder((PipelineCause)object); _visitables.add(this.object);}
            if (object instanceof Volume){ this.object= new VolumeBuilder((Volume)object); _visitables.add(this.object);}
            if (object instanceof FSGroupStrategyOptions){ this.object= new FSGroupStrategyOptionsBuilder((FSGroupStrategyOptions)object); _visitables.add(this.object);}
            if (object instanceof PipelineStatusJenkins){ this.object= new PipelineStatusJenkinsBuilder((PipelineStatusJenkins)object); _visitables.add(this.object);}
            if (object instanceof JenkinsBinding){ this.object= new JenkinsBindingBuilder((JenkinsBinding)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplate){ this.object= new PipelineTemplateBuilder((PipelineTemplate)object); _visitables.add(this.object);}
            if (object instanceof NodeAffinity){ this.object= new NodeAffinityBuilder((NodeAffinity)object); _visitables.add(this.object);}
            if (object instanceof PipelineConfigStatus){ this.object= new PipelineConfigStatusBuilder((PipelineConfigStatus)object); _visitables.add(this.object);}
            if (object instanceof ConfigMapList){ this.object= new ConfigMapListBuilder((ConfigMapList)object); _visitables.add(this.object);}
            if (object instanceof PipelineTriggeSchedule){ this.object= new PipelineTriggeScheduleBuilder((PipelineTriggeSchedule)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskTemplateList){ this.object= new PipelineTaskTemplateListBuilder((PipelineTaskTemplateList)object); _visitables.add(this.object);}
            if (object instanceof DaemonSetStatus){ this.object= new DaemonSetStatusBuilder((DaemonSetStatus)object); _visitables.add(this.object);}
            if (object instanceof BaseKubernetesList){ this.object= new BaseKubernetesListBuilder((BaseKubernetesList)object); _visitables.add(this.object);}
            if (object instanceof Initializer){ this.object= new InitializerBuilder((Initializer)object); _visitables.add(this.object);}
            if (object instanceof Status){ this.object= new StatusBuilder((Status)object); _visitables.add(this.object);}
            if (object instanceof CronJob){ this.object= new CronJobBuilder((CronJob)object); _visitables.add(this.object);}
            if (object instanceof ListMeta){ this.object= new ListMetaBuilder((ListMeta)object); _visitables.add(this.object);}
            if (object instanceof ComponentStatusList){ this.object= new ComponentStatusListBuilder((ComponentStatusList)object); _visitables.add(this.object);}
            if (object instanceof JenkinsBindingList){ this.object= new JenkinsBindingListBuilder((JenkinsBindingList)object); _visitables.add(this.object);}
            if (object instanceof BindingCondition){ this.object= new BindingConditionBuilder((BindingCondition)object); _visitables.add(this.object);}
            if (object instanceof NodeStatus){ this.object= new NodeStatusBuilder((NodeStatus)object); _visitables.add(this.object);}
            if (object instanceof GlobalParameter){ this.object= new GlobalParameterBuilder((GlobalParameter)object); _visitables.add(this.object);}
            if (object instanceof TokenReviewSpec){ this.object= new TokenReviewSpecBuilder((TokenReviewSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineEnvironment){ this.object= new PipelineEnvironmentBuilder((PipelineEnvironment)object); _visitables.add(this.object);}
            if (object instanceof EventList){ this.object= new EventListBuilder((EventList)object); _visitables.add(this.object);}
            if (object instanceof VolumeMount){ this.object= new VolumeMountBuilder((VolumeMount)object); _visitables.add(this.object);}
            if (object instanceof SubjectAccessReview){ this.object= new SubjectAccessReviewBuilder((SubjectAccessReview)object); _visitables.add(this.object);}
            if (object instanceof SELinuxOptions){ this.object= new SELinuxOptionsBuilder((SELinuxOptions)object); _visitables.add(this.object);}
            if (object instanceof DeploymentSpec){ this.object= new DeploymentSpecBuilder((DeploymentSpec)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeClaimList){ this.object= new PersistentVolumeClaimListBuilder((PersistentVolumeClaimList)object); _visitables.add(this.object);}
            if (object instanceof PodTemplate){ this.object= new PodTemplateBuilder((PodTemplate)object); _visitables.add(this.object);}
            if (object instanceof FCVolumeSource){ this.object= new FCVolumeSourceBuilder((FCVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof PipelineStatus){ this.object= new PipelineStatusBuilder((PipelineStatus)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateArgumentValue){ this.object= new PipelineTemplateArgumentValueBuilder((PipelineTemplateArgumentValue)object); _visitables.add(this.object);}
            if (object instanceof DaemonSetSpec){ this.object= new DaemonSetSpecBuilder((DaemonSetSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineStrategy){ this.object= new PipelineStrategyBuilder((PipelineStrategy)object); _visitables.add(this.object);}
            if (object instanceof Condition){ this.object= new ConditionBuilder((Condition)object); _visitables.add(this.object);}
            if (object instanceof ContainerStateWaiting){ this.object= new ContainerStateWaitingBuilder((ContainerStateWaiting)object); _visitables.add(this.object);}
            if (object instanceof TokenReview){ this.object= new TokenReviewBuilder((TokenReview)object); _visitables.add(this.object);}
            if (object instanceof ScaleSpec){ this.object= new ScaleSpecBuilder((ScaleSpec)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoBindingList){ this.object= new CodeRepoBindingListBuilder((CodeRepoBindingList)object); _visitables.add(this.object);}
            if (object instanceof NetworkPolicyPeer){ this.object= new NetworkPolicyPeerBuilder((NetworkPolicyPeer)object); _visitables.add(this.object);}
            if (object instanceof Preferences){ this.object= new PreferencesBuilder((Preferences)object); _visitables.add(this.object);}
            if (object instanceof MultiBranchBehaviours){ this.object= new MultiBranchBehavioursBuilder((MultiBranchBehaviours)object); _visitables.add(this.object);}
            if (object instanceof NodeDaemonEndpoints){ this.object= new NodeDaemonEndpointsBuilder((NodeDaemonEndpoints)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeList){ this.object= new PersistentVolumeListBuilder((PersistentVolumeList)object); _visitables.add(this.object);}
            if (object instanceof LimitRangeItem){ this.object= new LimitRangeItemBuilder((LimitRangeItem)object); _visitables.add(this.object);}
            if (object instanceof DaemonSetUpdateStrategy){ this.object= new DaemonSetUpdateStrategyBuilder((DaemonSetUpdateStrategy)object); _visitables.add(this.object);}
            if (object instanceof CustomResourceDefinition){ this.object= new CustomResourceDefinitionBuilder((CustomResourceDefinition)object); _visitables.add(this.object);}
            if (object instanceof IngressList){ this.object= new IngressListBuilder((IngressList)object); _visitables.add(this.object);}
            if (object instanceof FlexVolumeSource){ this.object= new FlexVolumeSourceBuilder((FlexVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof JenkinsAgent){ this.object= new JenkinsAgentBuilder((JenkinsAgent)object); _visitables.add(this.object);}
            if (object instanceof DeploymentCondition){ this.object= new DeploymentConditionBuilder((DeploymentCondition)object); _visitables.add(this.object);}
            if (object instanceof Config){ this.object= new ConfigBuilder((Config)object); _visitables.add(this.object);}
            if (object instanceof PipelineParameter){ this.object= new PipelineParameterBuilder((PipelineParameter)object); _visitables.add(this.object);}
            if (object instanceof NamespaceList){ this.object= new NamespaceListBuilder((NamespaceList)object); _visitables.add(this.object);}
            if (object instanceof PodDisruptionBudgetStatus){ this.object= new PodDisruptionBudgetStatusBuilder((PodDisruptionBudgetStatus)object); _visitables.add(this.object);}
            if (object instanceof CodeRepositorySpec){ this.object= new CodeRepositorySpecBuilder((CodeRepositorySpec)object); _visitables.add(this.object);}
            if (object instanceof PodDisruptionBudgetList){ this.object= new PodDisruptionBudgetListBuilder((PodDisruptionBudgetList)object); _visitables.add(this.object);}
            if (object instanceof DeploymentStatus){ this.object= new DeploymentStatusBuilder((DeploymentStatus)object); _visitables.add(this.object);}
            if (object instanceof StorageClass){ this.object= new StorageClassBuilder((StorageClass)object); _visitables.add(this.object);}
            if (object instanceof UserAccount){ this.object= new UserAccountBuilder((UserAccount)object); _visitables.add(this.object);}
            if (object instanceof QuobyteVolumeSource){ this.object= new QuobyteVolumeSourceBuilder((QuobyteVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof MultiBranchOrphan){ this.object= new MultiBranchOrphanBuilder((MultiBranchOrphan)object); _visitables.add(this.object);}
            if (object instanceof PreferredSchedulingTerm){ this.object= new PreferredSchedulingTermBuilder((PreferredSchedulingTerm)object); _visitables.add(this.object);}
            if (object instanceof HostPortRange){ this.object= new HostPortRangeBuilder((HostPortRange)object); _visitables.add(this.object);}
            if (object instanceof PodSecurityPolicyList){ this.object= new PodSecurityPolicyListBuilder((PodSecurityPolicyList)object); _visitables.add(this.object);}
            if (object instanceof ReplicationControllerSpec){ this.object= new ReplicationControllerSpecBuilder((ReplicationControllerSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineConfigList){ this.object= new PipelineConfigListBuilder((PipelineConfigList)object); _visitables.add(this.object);}
            if (object instanceof PipelineHookHTTPRequest){ this.object= new PipelineHookHTTPRequestBuilder((PipelineHookHTTPRequest)object); _visitables.add(this.object);}
            if (object instanceof ResourceFieldSelector){ this.object= new ResourceFieldSelectorBuilder((ResourceFieldSelector)object); _visitables.add(this.object);}
            if (object instanceof HostPathVolumeSource){ this.object= new HostPathVolumeSourceBuilder((HostPathVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof SELinuxStrategyOptions){ this.object= new SELinuxStrategyOptionsBuilder((SELinuxStrategyOptions)object); _visitables.add(this.object);}
            if (object instanceof PipelineConfigTemplate){ this.object= new PipelineConfigTemplateBuilder((PipelineConfigTemplate)object); _visitables.add(this.object);}
            if (object instanceof ContainerStatus){ this.object= new ContainerStatusBuilder((ContainerStatus)object); _visitables.add(this.object);}
            if (object instanceof ExecAction){ this.object= new ExecActionBuilder((ExecAction)object); _visitables.add(this.object);}
            if (object instanceof Preconditions){ this.object= new PreconditionsBuilder((Preconditions)object); _visitables.add(this.object);}
            if (object instanceof OwnerInRepository){ this.object= new OwnerInRepositoryBuilder((OwnerInRepository)object); _visitables.add(this.object);}
            if (object instanceof ClusterPipelineTemplateList){ this.object= new ClusterPipelineTemplateListBuilder((ClusterPipelineTemplateList)object); _visitables.add(this.object);}
            if (object instanceof IngressRule){ this.object= new IngressRuleBuilder((IngressRule)object); _visitables.add(this.object);}
            if (object instanceof StatefulSetStatus){ this.object= new StatefulSetStatusBuilder((StatefulSetStatus)object); _visitables.add(this.object);}
            if (object instanceof Namespace){ this.object= new NamespaceBuilder((Namespace)object); _visitables.add(this.object);}
            if (object instanceof NodeSelector){ this.object= new NodeSelectorBuilder((NodeSelector)object); _visitables.add(this.object);}
            if (object instanceof JenkinsfilePreviewOptions){ this.object= new JenkinsfilePreviewOptionsBuilder((JenkinsfilePreviewOptions)object); _visitables.add(this.object);}
            if (object instanceof PipelineList){ this.object= new PipelineListBuilder((PipelineList)object); _visitables.add(this.object);}
            if (object instanceof HTTPGetAction){ this.object= new HTTPGetActionBuilder((HTTPGetAction)object); _visitables.add(this.object);}
            if (object instanceof EndpointsList){ this.object= new EndpointsListBuilder((EndpointsList)object); _visitables.add(this.object);}
            if (object instanceof JenkinsfilePreview){ this.object= new JenkinsfilePreviewBuilder((JenkinsfilePreview)object); _visitables.add(this.object);}
            if (object instanceof ReplicationControllerStatus){ this.object= new ReplicationControllerStatusBuilder((ReplicationControllerStatus)object); _visitables.add(this.object);}
            if (object instanceof PipelineConfig){ this.object= new PipelineConfigBuilder((PipelineConfig)object); _visitables.add(this.object);}
            if (object instanceof Toleration){ this.object= new TolerationBuilder((Toleration)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoService){ this.object= new CodeRepoServiceBuilder((CodeRepoService)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskArgumentValidation){ this.object= new PipelineTaskArgumentValidationBuilder((PipelineTaskArgumentValidation)object); _visitables.add(this.object);}
            if (object instanceof AttachedVolume){ this.object= new AttachedVolumeBuilder((AttachedVolume)object); _visitables.add(this.object);}
            if (object instanceof StatefulSetList){ this.object= new StatefulSetListBuilder((StatefulSetList)object); _visitables.add(this.object);}
            if (object instanceof JenkinsStatus){ this.object= new JenkinsStatusBuilder((JenkinsStatus)object); _visitables.add(this.object);}
            if (object instanceof PipelineTriggerCodeChange){ this.object= new PipelineTriggerCodeChangeBuilder((PipelineTriggerCodeChange)object); _visitables.add(this.object);}
            if (object instanceof NamedExtension){ this.object= new NamedExtensionBuilder((NamedExtension)object); _visitables.add(this.object);}
            if (object instanceof ServiceList){ this.object= new ServiceListBuilder((ServiceList)object); _visitables.add(this.object);}
            if (object instanceof IngressStatus){ this.object= new IngressStatusBuilder((IngressStatus)object); _visitables.add(this.object);}
            if (object instanceof Initializers){ this.object= new InitializersBuilder((Initializers)object); _visitables.add(this.object);}
            if (object instanceof SecretKeySelector){ this.object= new SecretKeySelectorBuilder((SecretKeySelector)object); _visitables.add(this.object);}
            if (object instanceof PodCondition){ this.object= new PodConditionBuilder((PodCondition)object); _visitables.add(this.object);}
            if (object instanceof SupplementalGroupsStrategyOptions){ this.object= new SupplementalGroupsStrategyOptionsBuilder((SupplementalGroupsStrategyOptions)object); _visitables.add(this.object);}
            if (object instanceof ContainerStateTerminated){ this.object= new ContainerStateTerminatedBuilder((ContainerStateTerminated)object); _visitables.add(this.object);}
            if (object instanceof HostPortStatus){ this.object= new HostPortStatusBuilder((HostPortStatus)object); _visitables.add(this.object);}
            if (object instanceof ReplicaSetSpec){ this.object= new ReplicaSetSpecBuilder((ReplicaSetSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineSourceGit){ this.object= new PipelineSourceGitBuilder((PipelineSourceGit)object); _visitables.add(this.object);}
            if (object instanceof ISCSIVolumeSource){ this.object= new ISCSIVolumeSourceBuilder((ISCSIVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof AzureDiskVolumeSource){ this.object= new AzureDiskVolumeSourceBuilder((AzureDiskVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskArgumentWhen){ this.object= new PipelineTaskArgumentWhenBuilder((PipelineTaskArgumentWhen)object); _visitables.add(this.object);}
            if (object instanceof DownwardAPIVolumeSource){ this.object= new DownwardAPIVolumeSourceBuilder((DownwardAPIVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof StorageClassList){ this.object= new StorageClassListBuilder((StorageClassList)object); _visitables.add(this.object);}
            if (object instanceof GitRepoVolumeSource){ this.object= new GitRepoVolumeSourceBuilder((GitRepoVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof CodeRepositoryRef){ this.object= new CodeRepositoryRefBuilder((CodeRepositoryRef)object); _visitables.add(this.object);}
            if (object instanceof PodTemplateSpec){ this.object= new PodTemplateSpecBuilder((PodTemplateSpec)object); _visitables.add(this.object);}
            if (object instanceof JenkinsSpec){ this.object= new JenkinsSpecBuilder((JenkinsSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateTaskInstanceSpec){ this.object= new PipelineTemplateTaskInstanceSpecBuilder((PipelineTemplateTaskInstanceSpec)object); _visitables.add(this.object);}
            if (object instanceof ContainerStateRunning){ this.object= new ContainerStateRunningBuilder((ContainerStateRunning)object); _visitables.add(this.object);}
            if (object instanceof OwnerReference){ this.object= new OwnerReferenceBuilder((OwnerReference)object); _visitables.add(this.object);}
            if (object instanceof ConfigMapVolumeSource){ this.object= new ConfigMapVolumeSourceBuilder((ConfigMapVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof LabelSelectorRequirement){ this.object= new LabelSelectorRequirementBuilder((LabelSelectorRequirement)object); _visitables.add(this.object);}
            if (object instanceof JenkinsInstance){ this.object= new JenkinsInstanceBuilder((JenkinsInstance)object); _visitables.add(this.object);}
            if (object instanceof ResourceAttributes){ this.object= new ResourceAttributesBuilder((ResourceAttributes)object); _visitables.add(this.object);}
            if (object instanceof FlockerVolumeSource){ this.object= new FlockerVolumeSourceBuilder((FlockerVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof PodAntiAffinity){ this.object= new PodAntiAffinityBuilder((PodAntiAffinity)object); _visitables.add(this.object);}
            if (object instanceof NamedContext){ this.object= new NamedContextBuilder((NamedContext)object); _visitables.add(this.object);}
            if (object instanceof EnvVar){ this.object= new EnvVarBuilder((EnvVar)object); _visitables.add(this.object);}
            if (object instanceof ScaleIOVolumeSource){ this.object= new ScaleIOVolumeSourceBuilder((ScaleIOVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof MultiBranchPipeline){ this.object= new MultiBranchPipelineBuilder((MultiBranchPipeline)object); _visitables.add(this.object);}
            if (object instanceof Handler){ this.object= new HandlerBuilder((Handler)object); _visitables.add(this.object);}
            if (object instanceof ServiceStatus){ this.object= new ServiceStatusBuilder((ServiceStatus)object); _visitables.add(this.object);}
            if (object instanceof IDRange){ this.object= new IDRangeBuilder((IDRange)object); _visitables.add(this.object);}
            if (object instanceof HorizontalPodAutoscalerList){ this.object= new HorizontalPodAutoscalerListBuilder((HorizontalPodAutoscalerList)object); _visitables.add(this.object);}
            if (object instanceof ReplicaSetCondition){ this.object= new ReplicaSetConditionBuilder((ReplicaSetCondition)object); _visitables.add(this.object);}
            if (object instanceof PipelineSource){ this.object= new PipelineSourceBuilder((PipelineSource)object); _visitables.add(this.object);}
            if (object instanceof PodStatus){ this.object= new PodStatusBuilder((PodStatus)object); _visitables.add(this.object);}
            if (object instanceof AuthProviderConfig){ this.object= new AuthProviderConfigBuilder((AuthProviderConfig)object); _visitables.add(this.object);}
            if (object instanceof JenkinsPlugin){ this.object= new JenkinsPluginBuilder((JenkinsPlugin)object); _visitables.add(this.object);}
            if (object instanceof GCEPersistentDiskVolumeSource){ this.object= new GCEPersistentDiskVolumeSourceBuilder((GCEPersistentDiskVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof EmptyDirVolumeSource){ this.object= new EmptyDirVolumeSourceBuilder((EmptyDirVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoBinding){ this.object= new CodeRepoBindingBuilder((CodeRepoBinding)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateTask){ this.object= new PipelineTemplateTaskBuilder((PipelineTemplateTask)object); _visitables.add(this.object);}
            if (object instanceof Scale){ this.object= new ScaleBuilder((Scale)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskTemplate){ this.object= new PipelineTaskTemplateBuilder((PipelineTaskTemplate)object); _visitables.add(this.object);}
            if (object instanceof PodSpec){ this.object= new PodSpecBuilder((PodSpec)object); _visitables.add(this.object);}
            if (object instanceof NodeSpec){ this.object= new NodeSpecBuilder((NodeSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineConfigSpec){ this.object= new PipelineConfigSpecBuilder((PipelineConfigSpec)object); _visitables.add(this.object);}
            if (object instanceof ComponentCondition){ this.object= new ComponentConditionBuilder((ComponentCondition)object); _visitables.add(this.object);}
            if (object instanceof Pod){ this.object= new PodBuilder((Pod)object); _visitables.add(this.object);}
            if (object instanceof CephFSVolumeSource){ this.object= new CephFSVolumeSourceBuilder((CephFSVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof CodeRepositoryOwnerSync){ this.object= new CodeRepositoryOwnerSyncBuilder((CodeRepositoryOwnerSync)object); _visitables.add(this.object);}
            if (object instanceof ReplicationControllerCondition){ this.object= new ReplicationControllerConditionBuilder((ReplicationControllerCondition)object); _visitables.add(this.object);}
            if (object instanceof HorizontalPodAutoscaler){ this.object= new HorizontalPodAutoscalerBuilder((HorizontalPodAutoscaler)object); _visitables.add(this.object);}
            if (object instanceof ConfigMapProjection){ this.object= new ConfigMapProjectionBuilder((ConfigMapProjection)object); _visitables.add(this.object);}
            if (object instanceof CrossVersionObjectReference){ this.object= new CrossVersionObjectReferenceBuilder((CrossVersionObjectReference)object); _visitables.add(this.object);}
            if (object instanceof Cluster){ this.object= new ClusterBuilder((Cluster)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeClaimStatus){ this.object= new PersistentVolumeClaimStatusBuilder((PersistentVolumeClaimStatus)object); _visitables.add(this.object);}
            if (object instanceof NetworkPolicyIngressRule){ this.object= new NetworkPolicyIngressRuleBuilder((NetworkPolicyIngressRule)object); _visitables.add(this.object);}
            if (object instanceof LimitRangeList){ this.object= new LimitRangeListBuilder((LimitRangeList)object); _visitables.add(this.object);}
            if (object instanceof EndpointAddress){ this.object= new EndpointAddressBuilder((EndpointAddress)object); _visitables.add(this.object);}
            if (object instanceof Probe){ this.object= new ProbeBuilder((Probe)object); _visitables.add(this.object);}
            if (object instanceof ConfigMapKeySelector){ this.object= new ConfigMapKeySelectorBuilder((ConfigMapKeySelector)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateArgumentGroup){ this.object= new PipelineTemplateArgumentGroupBuilder((PipelineTemplateArgumentGroup)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskTemplateSpec){ this.object= new PipelineTaskTemplateSpecBuilder((PipelineTaskTemplateSpec)object); _visitables.add(this.object);}
            if (object instanceof CodeRepoServiceList){ this.object= new CodeRepoServiceListBuilder((CodeRepoServiceList)object); _visitables.add(this.object);}
            if (object instanceof PodAffinityTerm){ this.object= new PodAffinityTermBuilder((PodAffinityTerm)object); _visitables.add(this.object);}
            if (object instanceof JobList){ this.object= new JobListBuilder((JobList)object); _visitables.add(this.object);}
            if (object instanceof GlusterfsVolumeSource){ this.object= new GlusterfsVolumeSourceBuilder((GlusterfsVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof ThirdPartyResource){ this.object= new ThirdPartyResourceBuilder((ThirdPartyResource)object); _visitables.add(this.object);}
            if (object instanceof PortworxVolumeSource){ this.object= new PortworxVolumeSourceBuilder((PortworxVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof CronJobList){ this.object= new CronJobListBuilder((CronJobList)object); _visitables.add(this.object);}
            if (object instanceof RBDVolumeSource){ this.object= new RBDVolumeSourceBuilder((RBDVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof PipelineHook){ this.object= new PipelineHookBuilder((PipelineHook)object); _visitables.add(this.object);}
            if (object instanceof CronJobStatus){ this.object= new CronJobStatusBuilder((CronJobStatus)object); _visitables.add(this.object);}
            if (object instanceof StorageOSVolumeSource){ this.object= new StorageOSVolumeSourceBuilder((StorageOSVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof ServiceAccountList){ this.object= new ServiceAccountListBuilder((ServiceAccountList)object); _visitables.add(this.object);}
            if (object instanceof ComponentStatus){ this.object= new ComponentStatusBuilder((ComponentStatus)object); _visitables.add(this.object);}
            if (object instanceof ThirdPartyResourceList){ this.object= new ThirdPartyResourceListBuilder((ThirdPartyResourceList)object); _visitables.add(this.object);}
            if (object instanceof ProjectedVolumeSource){ this.object= new ProjectedVolumeSourceBuilder((ProjectedVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof HostPort){ this.object= new HostPortBuilder((HostPort)object); _visitables.add(this.object);}
            if (object instanceof IngressBackend){ this.object= new IngressBackendBuilder((IngressBackend)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeClaim){ this.object= new PersistentVolumeClaimBuilder((PersistentVolumeClaim)object); _visitables.add(this.object);}
            if (object instanceof PipelineDependency){ this.object= new PipelineDependencyBuilder((PipelineDependency)object); _visitables.add(this.object);}
            if (object instanceof NetworkPolicyList){ this.object= new NetworkPolicyListBuilder((NetworkPolicyList)object); _visitables.add(this.object);}
            if (object instanceof ResourceQuotaList){ this.object= new ResourceQuotaListBuilder((ResourceQuotaList)object); _visitables.add(this.object);}
            if (object instanceof ResourceRequirements){ this.object= new ResourceRequirementsBuilder((ResourceRequirements)object); _visitables.add(this.object);}
            if (object instanceof Secret){ this.object= new SecretBuilder((Secret)object); _visitables.add(this.object);}
            if (object instanceof JenkinsBindingSpec){ this.object= new JenkinsBindingSpecBuilder((JenkinsBindingSpec)object); _visitables.add(this.object);}
            if (object instanceof PodSecurityContext){ this.object= new PodSecurityContextBuilder((PodSecurityContext)object); _visitables.add(this.object);}
            if (object instanceof NodeSystemInfo){ this.object= new NodeSystemInfoBuilder((NodeSystemInfo)object); _visitables.add(this.object);}
            if (object instanceof ReplicationController){ this.object= new ReplicationControllerBuilder((ReplicationController)object); _visitables.add(this.object);}
            if (object instanceof CustomResourceDefinitionList){ this.object= new CustomResourceDefinitionListBuilder((CustomResourceDefinitionList)object); _visitables.add(this.object);}
            if (object instanceof Endpoints){ this.object= new EndpointsBuilder((Endpoints)object); _visitables.add(this.object);}
            if (object instanceof NodeSelectorRequirement){ this.object= new NodeSelectorRequirementBuilder((NodeSelectorRequirement)object); _visitables.add(this.object);}
            if (object instanceof LimitRange){ this.object= new LimitRangeBuilder((LimitRange)object); _visitables.add(this.object);}
            if (object instanceof LocalObjectReference){ this.object= new LocalObjectReferenceBuilder((LocalObjectReference)object); _visitables.add(this.object);}
            if (object instanceof CustomResourceDefinitionCondition){ this.object= new CustomResourceDefinitionConditionBuilder((CustomResourceDefinitionCondition)object); _visitables.add(this.object);}
            if (object instanceof RootPaths){ this.object= new RootPathsBuilder((RootPaths)object); _visitables.add(this.object);}
            if (object instanceof VsphereVirtualDiskVolumeSource){ this.object= new VsphereVirtualDiskVolumeSourceBuilder((VsphereVirtualDiskVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof DaemonEndpoint){ this.object= new DaemonEndpointBuilder((DaemonEndpoint)object); _visitables.add(this.object);}
            if (object instanceof KubernetesList){ this.object= new KubernetesListBuilder((KubernetesList)object); _visitables.add(this.object);}
            if (object instanceof SecretKeySetRef){ this.object= new SecretKeySetRefBuilder((SecretKeySetRef)object); _visitables.add(this.object);}
            if (object instanceof TokenReviewStatus){ this.object= new TokenReviewStatusBuilder((TokenReviewStatus)object); _visitables.add(this.object);}
            if (object instanceof CodeRepositoryStatusRepository){ this.object= new CodeRepositoryStatusRepositoryBuilder((CodeRepositoryStatusRepository)object); _visitables.add(this.object);}
            if (object instanceof EventSource){ this.object= new EventSourceBuilder((EventSource)object); _visitables.add(this.object);}
            if (object instanceof NetworkPolicy){ this.object= new NetworkPolicyBuilder((NetworkPolicy)object); _visitables.add(this.object);}
            if (object instanceof ContainerState){ this.object= new ContainerStateBuilder((ContainerState)object); _visitables.add(this.object);}
            if (object instanceof APIVersion){ this.object= new APIVersionBuilder((APIVersion)object); _visitables.add(this.object);}
            if (object instanceof ProjectNamespace){ this.object= new ProjectNamespaceBuilder((ProjectNamespace)object); _visitables.add(this.object);}
            if (object instanceof ProjectSpec){ this.object= new ProjectSpecBuilder((ProjectSpec)object); _visitables.add(this.object);}
            if (object instanceof HTTPHeader){ this.object= new HTTPHeaderBuilder((HTTPHeader)object); _visitables.add(this.object);}
            if (object instanceof Service){ this.object= new ServiceBuilder((Service)object); _visitables.add(this.object);}
            if (object instanceof NetworkPolicyPort){ this.object= new NetworkPolicyPortBuilder((NetworkPolicyPort)object); _visitables.add(this.object);}
            if (object instanceof IngressTLS){ this.object= new IngressTLSBuilder((IngressTLS)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateArgument){ this.object= new PipelineTemplateArgumentBuilder((PipelineTemplateArgument)object); _visitables.add(this.object);}
            if (object instanceof VolumeProjection){ this.object= new VolumeProjectionBuilder((VolumeProjection)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeSpec){ this.object= new PersistentVolumeSpecBuilder((PersistentVolumeSpec)object); _visitables.add(this.object);}
            if (object instanceof SecretEnvSource){ this.object= new SecretEnvSourceBuilder((SecretEnvSource)object); _visitables.add(this.object);}
            if (object instanceof NFSVolumeSource){ this.object= new NFSVolumeSourceBuilder((NFSVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof Event){ this.object= new EventBuilder((Event)object); _visitables.add(this.object);}
            if (object instanceof ObjectFieldSelector){ this.object= new ObjectFieldSelectorBuilder((ObjectFieldSelector)object); _visitables.add(this.object);}
            if (object instanceof IngressSpec){ this.object= new IngressSpecBuilder((IngressSpec)object); _visitables.add(this.object);}
            if (object instanceof NamespaceStatus){ this.object= new NamespaceStatusBuilder((NamespaceStatus)object); _visitables.add(this.object);}
            if (object instanceof SecurityContext){ this.object= new SecurityContextBuilder((SecurityContext)object); _visitables.add(this.object);}
            if (object instanceof JenkinsBindingStatus){ this.object= new JenkinsBindingStatusBuilder((JenkinsBindingStatus)object); _visitables.add(this.object);}
            if (object instanceof PodDisruptionBudgetSpec){ this.object= new PodDisruptionBudgetSpecBuilder((PodDisruptionBudgetSpec)object); _visitables.add(this.object);}
            if (object instanceof CodeRepositoryList){ this.object= new CodeRepositoryListBuilder((CodeRepositoryList)object); _visitables.add(this.object);}
            if (object instanceof Taint){ this.object= new TaintBuilder((Taint)object); _visitables.add(this.object);}
            if (object instanceof PodSecurityPolicySpec){ this.object= new PodSecurityPolicySpecBuilder((PodSecurityPolicySpec)object); _visitables.add(this.object);}
            if (object instanceof CustomResourceDefinitionNames){ this.object= new CustomResourceDefinitionNamesBuilder((CustomResourceDefinitionNames)object); _visitables.add(this.object);}
            if (object instanceof Node){ this.object= new NodeBuilder((Node)object); _visitables.add(this.object);}
            if (object instanceof Info){ this.object= new InfoBuilder((Info)object); _visitables.add(this.object);}
            if (object instanceof TCPSocketAction){ this.object= new TCPSocketActionBuilder((TCPSocketAction)object); _visitables.add(this.object);}
            if (object instanceof EnvFromSource){ this.object= new EnvFromSourceBuilder((EnvFromSource)object); _visitables.add(this.object);}
            if (object instanceof KeyToPath){ this.object= new KeyToPathBuilder((KeyToPath)object); _visitables.add(this.object);}
            if (object instanceof ReplicaSet){ this.object= new ReplicaSetBuilder((ReplicaSet)object); _visitables.add(this.object);}
            if (object instanceof NodeSelectorTerm){ this.object= new NodeSelectorTermBuilder((NodeSelectorTerm)object); _visitables.add(this.object);}
            if (object instanceof SubjectAccessReviewStatus){ this.object= new SubjectAccessReviewStatusBuilder((SubjectAccessReviewStatus)object); _visitables.add(this.object);}
            if (object instanceof DeploymentList){ this.object= new DeploymentListBuilder((DeploymentList)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeClaimSpec){ this.object= new PersistentVolumeClaimSpecBuilder((PersistentVolumeClaimSpec)object); _visitables.add(this.object);}
            if (object instanceof NamespaceSpec){ this.object= new NamespaceSpecBuilder((NamespaceSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskArgumentDisplay){ this.object= new PipelineTaskArgumentDisplayBuilder((PipelineTaskArgumentDisplay)object); _visitables.add(this.object);}
            if (object instanceof EndpointSubset){ this.object= new EndpointSubsetBuilder((EndpointSubset)object); _visitables.add(this.object);}
            if (object instanceof Patch){ this.object= new PatchBuilder((Patch)object); _visitables.add(this.object);}
            if (object instanceof JobTemplateSpec){ this.object= new JobTemplateSpecBuilder((JobTemplateSpec)object); _visitables.add(this.object);}
            if (object instanceof LoadBalancerStatus){ this.object= new LoadBalancerStatusBuilder((LoadBalancerStatus)object); _visitables.add(this.object);}
            if (object instanceof ReplicaSetStatus){ this.object= new ReplicaSetStatusBuilder((ReplicaSetStatus)object); _visitables.add(this.object);}
            if (object instanceof ClusterPipelineTemplate){ this.object= new ClusterPipelineTemplateBuilder((ClusterPipelineTemplate)object); _visitables.add(this.object);}
            if (object instanceof PipelineConfigTemplateSpec){ this.object= new PipelineConfigTemplateSpecBuilder((PipelineConfigTemplateSpec)object); _visitables.add(this.object);}
            if (object instanceof DaemonSetList){ this.object= new DaemonSetListBuilder((DaemonSetList)object); _visitables.add(this.object);}
            if (object instanceof HorizontalPodAutoscalerStatus){ this.object= new HorizontalPodAutoscalerStatusBuilder((HorizontalPodAutoscalerStatus)object); _visitables.add(this.object);}
            if (object instanceof SubjectAccessReviewSpec){ this.object= new SubjectAccessReviewSpecBuilder((SubjectAccessReviewSpec)object); _visitables.add(this.object);}
            if (object instanceof Lifecycle){ this.object= new LifecycleBuilder((Lifecycle)object); _visitables.add(this.object);}
            if (object instanceof Job){ this.object= new JobBuilder((Job)object); _visitables.add(this.object);}
            if (object instanceof NamedAuthInfo){ this.object= new NamedAuthInfoBuilder((NamedAuthInfo)object); _visitables.add(this.object);}
            if (object instanceof ContainerImage){ this.object= new ContainerImageBuilder((ContainerImage)object); _visitables.add(this.object);}
            if (object instanceof StatefulSetUpdateStrategy){ this.object= new StatefulSetUpdateStrategyBuilder((StatefulSetUpdateStrategy)object); _visitables.add(this.object);}
            if (object instanceof PipelineTriggerCron){ this.object= new PipelineTriggerCronBuilder((PipelineTriggerCron)object); _visitables.add(this.object);}
            if (object instanceof NonResourceAttributes){ this.object= new NonResourceAttributesBuilder((NonResourceAttributes)object); _visitables.add(this.object);}
            if (object instanceof ObjectMeta){ this.object= new ObjectMetaBuilder((ObjectMeta)object); _visitables.add(this.object);}
            if (object instanceof EnvVarSource){ this.object= new EnvVarSourceBuilder((EnvVarSource)object); _visitables.add(this.object);}
            if (object instanceof RollingUpdateDaemonSet){ this.object= new RollingUpdateDaemonSetBuilder((RollingUpdateDaemonSet)object); _visitables.add(this.object);}
            if (object instanceof PhotonPersistentDiskVolumeSource){ this.object= new PhotonPersistentDiskVolumeSourceBuilder((PhotonPersistentDiskVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof ReplicationControllerList){ this.object= new ReplicationControllerListBuilder((ReplicationControllerList)object); _visitables.add(this.object);}
            if (object instanceof HTTPIngressPath){ this.object= new HTTPIngressPathBuilder((HTTPIngressPath)object); _visitables.add(this.object);}
            if (object instanceof JobStatus){ this.object= new JobStatusBuilder((JobStatus)object); _visitables.add(this.object);}
            if (object instanceof DownwardAPIVolumeFile){ this.object= new DownwardAPIVolumeFileBuilder((DownwardAPIVolumeFile)object); _visitables.add(this.object);}
            if (object instanceof RollbackConfig){ this.object= new RollbackConfigBuilder((RollbackConfig)object); _visitables.add(this.object);}
            if (object instanceof Capabilities){ this.object= new CapabilitiesBuilder((Capabilities)object); _visitables.add(this.object);}
            if (object instanceof PodAffinity){ this.object= new PodAffinityBuilder((PodAffinity)object); _visitables.add(this.object);}
            if (object instanceof ServiceSpec){ this.object= new ServiceSpecBuilder((ServiceSpec)object); _visitables.add(this.object);}
            if (object instanceof ResourceQuotaStatus){ this.object= new ResourceQuotaStatusBuilder((ResourceQuotaStatus)object); _visitables.add(this.object);}
            if (object instanceof ClusterPipelineTaskTemplate){ this.object= new ClusterPipelineTaskTemplateBuilder((ClusterPipelineTaskTemplate)object); _visitables.add(this.object);}
            if (object instanceof ReplicaSetList){ this.object= new ReplicaSetListBuilder((ReplicaSetList)object); _visitables.add(this.object);}
            if (object instanceof StatefulSetSpec){ this.object= new StatefulSetSpecBuilder((StatefulSetSpec)object); _visitables.add(this.object);}
            if (object instanceof SecretProjection){ this.object= new SecretProjectionBuilder((SecretProjection)object); _visitables.add(this.object);}
            if (object instanceof Deployment){ this.object= new DeploymentBuilder((Deployment)object); _visitables.add(this.object);}
            if (object instanceof JobCondition){ this.object= new JobConditionBuilder((JobCondition)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeClaimVolumeSource){ this.object= new PersistentVolumeClaimVolumeSourceBuilder((PersistentVolumeClaimVolumeSource)object); _visitables.add(this.object);}
            if (object instanceof Jenkins){ this.object= new JenkinsBuilder((Jenkins)object); _visitables.add(this.object);}
            if (object instanceof DeploymentStrategy){ this.object= new DeploymentStrategyBuilder((DeploymentStrategy)object); _visitables.add(this.object);}
            if (object instanceof ContainerPort){ this.object= new ContainerPortBuilder((ContainerPort)object); _visitables.add(this.object);}
            if (object instanceof NodeAddress){ this.object= new NodeAddressBuilder((NodeAddress)object); _visitables.add(this.object);}
            if (object instanceof PodTemplateList){ this.object= new PodTemplateListBuilder((PodTemplateList)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolumeStatus){ this.object= new PersistentVolumeStatusBuilder((PersistentVolumeStatus)object); _visitables.add(this.object);}
            if (object instanceof DaemonSet){ this.object= new DaemonSetBuilder((DaemonSet)object); _visitables.add(this.object);}
            if (object instanceof PodDisruptionBudget){ this.object= new PodDisruptionBudgetBuilder((PodDisruptionBudget)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskArgumentAction){ this.object= new PipelineTaskArgumentActionBuilder((PipelineTaskArgumentAction)object); _visitables.add(this.object);}
            if (object instanceof ProjectStatus){ this.object= new ProjectStatusBuilder((ProjectStatus)object); _visitables.add(this.object);}
            if (object instanceof PipelineSpec){ this.object= new PipelineSpecBuilder((PipelineSpec)object); _visitables.add(this.object);}
            if (object instanceof ScaleStatus){ this.object= new ScaleStatusBuilder((ScaleStatus)object); _visitables.add(this.object);}
            if (object instanceof Project){ this.object= new ProjectBuilder((Project)object); _visitables.add(this.object);}
            if (object instanceof PipelineTaskArgument){ this.object= new PipelineTaskArgumentBuilder((PipelineTaskArgument)object); _visitables.add(this.object);}
            if (object instanceof WatchEvent){ this.object= new WatchEventBuilder((WatchEvent)object); _visitables.add(this.object);}
            if (object instanceof ConfigMapEnvSource){ this.object= new ConfigMapEnvSourceBuilder((ConfigMapEnvSource)object); _visitables.add(this.object);}
            if (object instanceof HostAlias){ this.object= new HostAliasBuilder((HostAlias)object); _visitables.add(this.object);}
            if (object instanceof HTTPIngressRuleValue){ this.object= new HTTPIngressRuleValueBuilder((HTTPIngressRuleValue)object); _visitables.add(this.object);}
            if (object instanceof EndpointPort){ this.object= new EndpointPortBuilder((EndpointPort)object); _visitables.add(this.object);}
            if (object instanceof StatusCause){ this.object= new StatusCauseBuilder((StatusCause)object); _visitables.add(this.object);}
            if (object instanceof I18nName){ this.object= new I18nNameBuilder((I18nName)object); _visitables.add(this.object);}
            if (object instanceof PipelineRunLimits){ this.object= new PipelineRunLimitsBuilder((PipelineRunLimits)object); _visitables.add(this.object);}
            if (object instanceof NodeCondition){ this.object= new NodeConditionBuilder((NodeCondition)object); _visitables.add(this.object);}
            if (object instanceof RollingUpdateDeployment){ this.object= new RollingUpdateDeploymentBuilder((RollingUpdateDeployment)object); _visitables.add(this.object);}
            if (object instanceof PipelineStage){ this.object= new PipelineStageBuilder((PipelineStage)object); _visitables.add(this.object);}
            if (object instanceof OriginCodeRepository){ this.object= new OriginCodeRepositoryBuilder((OriginCodeRepository)object); _visitables.add(this.object);}
            if (object instanceof ObjectReference){ this.object= new ObjectReferenceBuilder((ObjectReference)object); _visitables.add(this.object);}
            if (object instanceof PipelineTemplateSpec){ this.object= new PipelineTemplateSpecBuilder((PipelineTemplateSpec)object); _visitables.add(this.object);}
            if (object instanceof PipelineStrategyJenkins){ this.object= new PipelineStrategyJenkinsBuilder((PipelineStrategyJenkins)object); _visitables.add(this.object);}
            if (object instanceof PersistentVolume){ this.object= new PersistentVolumeBuilder((PersistentVolume)object); _visitables.add(this.object);}
            if (object instanceof CodeRepository){ this.object= new CodeRepositoryBuilder((CodeRepository)object); _visitables.add(this.object);}
            return (A) this;
    }

    public Boolean hasObject(){
            return this.object!=null;
    }

    public A withRepositoryCommitObject(RepositoryCommit repositoryCommitObject){
            _visitables.remove(this.object);
            if (repositoryCommitObject!=null){ this.object= new RepositoryCommitBuilder(repositoryCommitObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RepositoryCommitObjectNested withNewRepositoryCommitObject(){
            return new RepositoryCommitObjectNestedImpl();
    }

    public WatchEventFluent.RepositoryCommitObjectNested withNewRepositoryCommitObjectLike(RepositoryCommit item){
            return new RepositoryCommitObjectNestedImpl(item);
    }

    public A withNewRepositoryCommitObject(String commitAt,String commitID,String commitMessage,String committerEmail,String committerName){
            return (A)withRepositoryCommitObject(new RepositoryCommit(commitAt, commitID, commitMessage, committerEmail, committerName));
    }

    public A withAffinityObject(Affinity affinityObject){
            _visitables.remove(this.object);
            if (affinityObject!=null){ this.object= new AffinityBuilder(affinityObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AffinityObjectNested withNewAffinityObject(){
            return new AffinityObjectNestedImpl();
    }

    public WatchEventFluent.AffinityObjectNested withNewAffinityObjectLike(Affinity item){
            return new AffinityObjectNestedImpl(item);
    }

    public A withNamedClusterObject(NamedCluster namedClusterObject){
            _visitables.remove(this.object);
            if (namedClusterObject!=null){ this.object= new NamedClusterBuilder(namedClusterObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NamedClusterObjectNested withNewNamedClusterObject(){
            return new NamedClusterObjectNestedImpl();
    }

    public WatchEventFluent.NamedClusterObjectNested withNewNamedClusterObjectLike(NamedCluster item){
            return new NamedClusterObjectNestedImpl(item);
    }

    public A withAWSElasticBlockStoreVolumeSourceObject(AWSElasticBlockStoreVolumeSource aWSElasticBlockStoreVolumeSourceObject){
            _visitables.remove(this.object);
            if (aWSElasticBlockStoreVolumeSourceObject!=null){ this.object= new AWSElasticBlockStoreVolumeSourceBuilder(aWSElasticBlockStoreVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AWSElasticBlockStoreVolumeSourceObjectNested withNewAWSElasticBlockStoreVolumeSourceObject(){
            return new AWSElasticBlockStoreVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.AWSElasticBlockStoreVolumeSourceObjectNested withNewAWSElasticBlockStoreVolumeSourceObjectLike(AWSElasticBlockStoreVolumeSource item){
            return new AWSElasticBlockStoreVolumeSourceObjectNestedImpl(item);
    }

    public A withNewAWSElasticBlockStoreVolumeSourceObject(String fsType,Integer partition,Boolean readOnly,String volumeID){
            return (A)withAWSElasticBlockStoreVolumeSourceObject(new AWSElasticBlockStoreVolumeSource(fsType, partition, readOnly, volumeID));
    }

    public A withContextObject(Context contextObject){
            _visitables.remove(this.object);
            if (contextObject!=null){ this.object= new ContextBuilder(contextObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContextObjectNested withNewContextObject(){
            return new ContextObjectNestedImpl();
    }

    public WatchEventFluent.ContextObjectNested withNewContextObjectLike(Context item){
            return new ContextObjectNestedImpl(item);
    }

    public A withServicePortObject(ServicePort servicePortObject){
            _visitables.remove(this.object);
            if (servicePortObject!=null){ this.object= new ServicePortBuilder(servicePortObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServicePortObjectNested withNewServicePortObject(){
            return new ServicePortObjectNestedImpl();
    }

    public WatchEventFluent.ServicePortObjectNested withNewServicePortObjectLike(ServicePort item){
            return new ServicePortObjectNestedImpl(item);
    }

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

    public WatchEventFluent.BindingObjectNested withNewBindingObject(){
            return new BindingObjectNestedImpl();
    }

    public WatchEventFluent.BindingObjectNested withNewBindingObjectLike(Binding item){
            return new BindingObjectNestedImpl(item);
    }

    public A withAuthInfoObject(AuthInfo authInfoObject){
            _visitables.remove(this.object);
            if (authInfoObject!=null){ this.object= new AuthInfoBuilder(authInfoObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AuthInfoObjectNested withNewAuthInfoObject(){
            return new AuthInfoObjectNestedImpl();
    }

    public WatchEventFluent.AuthInfoObjectNested withNewAuthInfoObjectLike(AuthInfo item){
            return new AuthInfoObjectNestedImpl(item);
    }

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

    public WatchEventFluent.IngressObjectNested withNewIngressObject(){
            return new IngressObjectNestedImpl();
    }

    public WatchEventFluent.IngressObjectNested withNewIngressObjectLike(Ingress item){
            return new IngressObjectNestedImpl(item);
    }

    public A withClusterPipelineTaskTemplateListObject(ClusterPipelineTaskTemplateList clusterPipelineTaskTemplateListObject){
            _visitables.remove(this.object);
            if (clusterPipelineTaskTemplateListObject!=null){ this.object= new ClusterPipelineTaskTemplateListBuilder(clusterPipelineTaskTemplateListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ClusterPipelineTaskTemplateListObjectNested withNewClusterPipelineTaskTemplateListObject(){
            return new ClusterPipelineTaskTemplateListObjectNestedImpl();
    }

    public WatchEventFluent.ClusterPipelineTaskTemplateListObjectNested withNewClusterPipelineTaskTemplateListObjectLike(ClusterPipelineTaskTemplateList item){
            return new ClusterPipelineTaskTemplateListObjectNestedImpl(item);
    }

    public A withRollingUpdateStatefulSetStrategyObject(RollingUpdateStatefulSetStrategy rollingUpdateStatefulSetStrategyObject){
            _visitables.remove(this.object);
            if (rollingUpdateStatefulSetStrategyObject!=null){ this.object= new RollingUpdateStatefulSetStrategyBuilder(rollingUpdateStatefulSetStrategyObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RollingUpdateStatefulSetStrategyObjectNested withNewRollingUpdateStatefulSetStrategyObject(){
            return new RollingUpdateStatefulSetStrategyObjectNestedImpl();
    }

    public WatchEventFluent.RollingUpdateStatefulSetStrategyObjectNested withNewRollingUpdateStatefulSetStrategyObjectLike(RollingUpdateStatefulSetStrategy item){
            return new RollingUpdateStatefulSetStrategyObjectNestedImpl(item);
    }

    public A withNewRollingUpdateStatefulSetStrategyObject(Integer partition){
            return (A)withRollingUpdateStatefulSetStrategyObject(new RollingUpdateStatefulSetStrategy(partition));
    }

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

    public WatchEventFluent.LocalSubjectAccessReviewObjectNested withNewLocalSubjectAccessReviewObject(){
            return new LocalSubjectAccessReviewObjectNestedImpl();
    }

    public WatchEventFluent.LocalSubjectAccessReviewObjectNested withNewLocalSubjectAccessReviewObjectLike(LocalSubjectAccessReview item){
            return new LocalSubjectAccessReviewObjectNestedImpl(item);
    }

    public A withStatefulSetObject(StatefulSet statefulSetObject){
            _visitables.remove(this.object);
            if (statefulSetObject!=null){ this.object= new StatefulSetBuilder(statefulSetObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatefulSetObjectNested withNewStatefulSetObject(){
            return new StatefulSetObjectNestedImpl();
    }

    public WatchEventFluent.StatefulSetObjectNested withNewStatefulSetObjectLike(StatefulSet item){
            return new StatefulSetObjectNestedImpl(item);
    }

    public A withPipelineTaskArgumentSchemaObject(PipelineTaskArgumentSchema pipelineTaskArgumentSchemaObject){
            _visitables.remove(this.object);
            if (pipelineTaskArgumentSchemaObject!=null){ this.object= new PipelineTaskArgumentSchemaBuilder(pipelineTaskArgumentSchemaObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskArgumentSchemaObjectNested withNewPipelineTaskArgumentSchemaObject(){
            return new PipelineTaskArgumentSchemaObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskArgumentSchemaObjectNested withNewPipelineTaskArgumentSchemaObjectLike(PipelineTaskArgumentSchema item){
            return new PipelineTaskArgumentSchemaObjectNestedImpl(item);
    }

    public A withNewPipelineTaskArgumentSchemaObject(String type){
            return (A)withPipelineTaskArgumentSchemaObject(new PipelineTaskArgumentSchema(type));
    }

    public A withContainerObject(Container containerObject){
            _visitables.remove(this.object);
            if (containerObject!=null){ this.object= new ContainerBuilder(containerObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerObjectNested withNewContainerObject(){
            return new ContainerObjectNestedImpl();
    }

    public WatchEventFluent.ContainerObjectNested withNewContainerObjectLike(Container item){
            return new ContainerObjectNestedImpl(item);
    }

    public A withResourceQuotaSpecObject(ResourceQuotaSpec resourceQuotaSpecObject){
            _visitables.remove(this.object);
            if (resourceQuotaSpecObject!=null){ this.object= new ResourceQuotaSpecBuilder(resourceQuotaSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceQuotaSpecObjectNested withNewResourceQuotaSpecObject(){
            return new ResourceQuotaSpecObjectNestedImpl();
    }

    public WatchEventFluent.ResourceQuotaSpecObjectNested withNewResourceQuotaSpecObjectLike(ResourceQuotaSpec item){
            return new ResourceQuotaSpecObjectNestedImpl(item);
    }

    public A withPipelineTemplateTaskInstanceObject(PipelineTemplateTaskInstance pipelineTemplateTaskInstanceObject){
            _visitables.remove(this.object);
            if (pipelineTemplateTaskInstanceObject!=null){ this.object= new PipelineTemplateTaskInstanceBuilder(pipelineTemplateTaskInstanceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateTaskInstanceObjectNested withNewPipelineTemplateTaskInstanceObject(){
            return new PipelineTemplateTaskInstanceObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateTaskInstanceObjectNested withNewPipelineTemplateTaskInstanceObjectLike(PipelineTemplateTaskInstance item){
            return new PipelineTemplateTaskInstanceObjectNestedImpl(item);
    }

    public A withPipelineTemplateListObject(PipelineTemplateList pipelineTemplateListObject){
            _visitables.remove(this.object);
            if (pipelineTemplateListObject!=null){ this.object= new PipelineTemplateListBuilder(pipelineTemplateListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateListObjectNested withNewPipelineTemplateListObject(){
            return new PipelineTemplateListObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateListObjectNested withNewPipelineTemplateListObjectLike(PipelineTemplateList item){
            return new PipelineTemplateListObjectNestedImpl(item);
    }

    public A withPipelineTaskOptionObject(PipelineTaskOption pipelineTaskOptionObject){
            _visitables.remove(this.object);
            if (pipelineTaskOptionObject!=null){ this.object= new PipelineTaskOptionBuilder(pipelineTaskOptionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskOptionObjectNested withNewPipelineTaskOptionObject(){
            return new PipelineTaskOptionObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskOptionObjectNested withNewPipelineTaskOptionObjectLike(PipelineTaskOption item){
            return new PipelineTaskOptionObjectNestedImpl(item);
    }

    public A withNewPipelineTaskOptionObject(Long timeout){
            return (A)withPipelineTaskOptionObject(new PipelineTaskOption(timeout));
    }

    public A withJobSpecObject(JobSpec jobSpecObject){
            _visitables.remove(this.object);
            if (jobSpecObject!=null){ this.object= new JobSpecBuilder(jobSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JobSpecObjectNested withNewJobSpecObject(){
            return new JobSpecObjectNestedImpl();
    }

    public WatchEventFluent.JobSpecObjectNested withNewJobSpecObjectLike(JobSpec item){
            return new JobSpecObjectNestedImpl(item);
    }

    public A withSecretListObject(SecretList secretListObject){
            _visitables.remove(this.object);
            if (secretListObject!=null){ this.object= new SecretListBuilder(secretListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretListObjectNested withNewSecretListObject(){
            return new SecretListObjectNestedImpl();
    }

    public WatchEventFluent.SecretListObjectNested withNewSecretListObjectLike(SecretList item){
            return new SecretListObjectNestedImpl(item);
    }

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

    public WatchEventFluent.JenkinsListObjectNested withNewJenkinsListObject(){
            return new JenkinsListObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsListObjectNested withNewJenkinsListObjectLike(JenkinsList item){
            return new JenkinsListObjectNestedImpl(item);
    }

    public A withLabelSelectorObject(LabelSelector labelSelectorObject){
            _visitables.remove(this.object);
            if (labelSelectorObject!=null){ this.object= new LabelSelectorBuilder(labelSelectorObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LabelSelectorObjectNested withNewLabelSelectorObject(){
            return new LabelSelectorObjectNestedImpl();
    }

    public WatchEventFluent.LabelSelectorObjectNested withNewLabelSelectorObjectLike(LabelSelector item){
            return new LabelSelectorObjectNestedImpl(item);
    }

    public A withCronJobSpecObject(CronJobSpec cronJobSpecObject){
            _visitables.remove(this.object);
            if (cronJobSpecObject!=null){ this.object= new CronJobSpecBuilder(cronJobSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CronJobSpecObjectNested withNewCronJobSpecObject(){
            return new CronJobSpecObjectNestedImpl();
    }

    public WatchEventFluent.CronJobSpecObjectNested withNewCronJobSpecObjectLike(CronJobSpec item){
            return new CronJobSpecObjectNestedImpl(item);
    }

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

    public WatchEventFluent.DeleteOptionsObjectNested withNewDeleteOptionsObject(){
            return new DeleteOptionsObjectNestedImpl();
    }

    public WatchEventFluent.DeleteOptionsObjectNested withNewDeleteOptionsObjectLike(DeleteOptions item){
            return new DeleteOptionsObjectNestedImpl(item);
    }

    public A withPipelineTriggerObject(PipelineTrigger pipelineTriggerObject){
            _visitables.remove(this.object);
            if (pipelineTriggerObject!=null){ this.object= new PipelineTriggerBuilder(pipelineTriggerObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTriggerObjectNested withNewPipelineTriggerObject(){
            return new PipelineTriggerObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTriggerObjectNested withNewPipelineTriggerObjectLike(PipelineTrigger item){
            return new PipelineTriggerObjectNestedImpl(item);
    }

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

    public WatchEventFluent.DeploymentRollbackObjectNested withNewDeploymentRollbackObject(){
            return new DeploymentRollbackObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentRollbackObjectNested withNewDeploymentRollbackObjectLike(DeploymentRollback item){
            return new DeploymentRollbackObjectNestedImpl(item);
    }

    public A withSecretVolumeSourceObject(SecretVolumeSource secretVolumeSourceObject){
            _visitables.remove(this.object);
            if (secretVolumeSourceObject!=null){ this.object= new SecretVolumeSourceBuilder(secretVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretVolumeSourceObjectNested withNewSecretVolumeSourceObject(){
            return new SecretVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.SecretVolumeSourceObjectNested withNewSecretVolumeSourceObjectLike(SecretVolumeSource item){
            return new SecretVolumeSourceObjectNestedImpl(item);
    }

    public A withDownwardAPIProjectionObject(DownwardAPIProjection downwardAPIProjectionObject){
            _visitables.remove(this.object);
            if (downwardAPIProjectionObject!=null){ this.object= new DownwardAPIProjectionBuilder(downwardAPIProjectionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DownwardAPIProjectionObjectNested withNewDownwardAPIProjectionObject(){
            return new DownwardAPIProjectionObjectNestedImpl();
    }

    public WatchEventFluent.DownwardAPIProjectionObjectNested withNewDownwardAPIProjectionObjectLike(DownwardAPIProjection item){
            return new DownwardAPIProjectionObjectNestedImpl(item);
    }

    public A withLoadBalancerIngressObject(LoadBalancerIngress loadBalancerIngressObject){
            _visitables.remove(this.object);
            if (loadBalancerIngressObject!=null){ this.object= new LoadBalancerIngressBuilder(loadBalancerIngressObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LoadBalancerIngressObjectNested withNewLoadBalancerIngressObject(){
            return new LoadBalancerIngressObjectNestedImpl();
    }

    public WatchEventFluent.LoadBalancerIngressObjectNested withNewLoadBalancerIngressObjectLike(LoadBalancerIngress item){
            return new LoadBalancerIngressObjectNestedImpl(item);
    }

    public A withNewLoadBalancerIngressObject(String hostname,String ip){
            return (A)withLoadBalancerIngressObject(new LoadBalancerIngress(hostname, ip));
    }

    public A withCodeRepoBindingAccountObject(CodeRepoBindingAccount codeRepoBindingAccountObject){
            _visitables.remove(this.object);
            if (codeRepoBindingAccountObject!=null){ this.object= new CodeRepoBindingAccountBuilder(codeRepoBindingAccountObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoBindingAccountObjectNested withNewCodeRepoBindingAccountObject(){
            return new CodeRepoBindingAccountObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoBindingAccountObjectNested withNewCodeRepoBindingAccountObjectLike(CodeRepoBindingAccount item){
            return new CodeRepoBindingAccountObjectNestedImpl(item);
    }

    public A withHorizontalPodAutoscalerSpecObject(HorizontalPodAutoscalerSpec horizontalPodAutoscalerSpecObject){
            _visitables.remove(this.object);
            if (horizontalPodAutoscalerSpecObject!=null){ this.object= new HorizontalPodAutoscalerSpecBuilder(horizontalPodAutoscalerSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HorizontalPodAutoscalerSpecObjectNested withNewHorizontalPodAutoscalerSpecObject(){
            return new HorizontalPodAutoscalerSpecObjectNestedImpl();
    }

    public WatchEventFluent.HorizontalPodAutoscalerSpecObjectNested withNewHorizontalPodAutoscalerSpecObjectLike(HorizontalPodAutoscalerSpec item){
            return new HorizontalPodAutoscalerSpecObjectNestedImpl(item);
    }

    public A withProjectNamespaceStatusObject(ProjectNamespaceStatus projectNamespaceStatusObject){
            _visitables.remove(this.object);
            if (projectNamespaceStatusObject!=null){ this.object= new ProjectNamespaceStatusBuilder(projectNamespaceStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectNamespaceStatusObjectNested withNewProjectNamespaceStatusObject(){
            return new ProjectNamespaceStatusObjectNestedImpl();
    }

    public WatchEventFluent.ProjectNamespaceStatusObjectNested withNewProjectNamespaceStatusObjectLike(ProjectNamespaceStatus item){
            return new ProjectNamespaceStatusObjectNestedImpl(item);
    }

    public A withNewProjectNamespaceStatusObject(String name,String status){
            return (A)withProjectNamespaceStatusObject(new ProjectNamespaceStatus(name, status));
    }

    public A withKubernetesRunAsUserStrategyOptionsObject(KubernetesRunAsUserStrategyOptions kubernetesRunAsUserStrategyOptionsObject){
            _visitables.remove(this.object);
            if (kubernetesRunAsUserStrategyOptionsObject!=null){ this.object= new KubernetesRunAsUserStrategyOptionsBuilder(kubernetesRunAsUserStrategyOptionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.KubernetesRunAsUserStrategyOptionsObjectNested withNewKubernetesRunAsUserStrategyOptionsObject(){
            return new KubernetesRunAsUserStrategyOptionsObjectNestedImpl();
    }

    public WatchEventFluent.KubernetesRunAsUserStrategyOptionsObjectNested withNewKubernetesRunAsUserStrategyOptionsObjectLike(KubernetesRunAsUserStrategyOptions item){
            return new KubernetesRunAsUserStrategyOptionsObjectNestedImpl(item);
    }

    public A withStatusDetailsObject(StatusDetails statusDetailsObject){
            _visitables.remove(this.object);
            if (statusDetailsObject!=null){ this.object= new StatusDetailsBuilder(statusDetailsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatusDetailsObjectNested withNewStatusDetailsObject(){
            return new StatusDetailsObjectNestedImpl();
    }

    public WatchEventFluent.StatusDetailsObjectNested withNewStatusDetailsObjectLike(StatusDetails item){
            return new StatusDetailsObjectNestedImpl(item);
    }

    public A withPipelineTaskApproveObject(PipelineTaskApprove pipelineTaskApproveObject){
            _visitables.remove(this.object);
            if (pipelineTaskApproveObject!=null){ this.object= new PipelineTaskApproveBuilder(pipelineTaskApproveObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskApproveObjectNested withNewPipelineTaskApproveObject(){
            return new PipelineTaskApproveObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskApproveObjectNested withNewPipelineTaskApproveObjectLike(PipelineTaskApprove item){
            return new PipelineTaskApproveObjectNestedImpl(item);
    }

    public A withNewPipelineTaskApproveObject(String message,Long timeout){
            return (A)withPipelineTaskApproveObject(new PipelineTaskApprove(message, timeout));
    }

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

    public WatchEventFluent.PodSecurityPolicyObjectNested withNewPodSecurityPolicyObject(){
            return new PodSecurityPolicyObjectNestedImpl();
    }

    public WatchEventFluent.PodSecurityPolicyObjectNested withNewPodSecurityPolicyObjectLike(PodSecurityPolicy item){
            return new PodSecurityPolicyObjectNestedImpl(item);
    }

    public A withWeightedPodAffinityTermObject(WeightedPodAffinityTerm weightedPodAffinityTermObject){
            _visitables.remove(this.object);
            if (weightedPodAffinityTermObject!=null){ this.object= new WeightedPodAffinityTermBuilder(weightedPodAffinityTermObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.WeightedPodAffinityTermObjectNested withNewWeightedPodAffinityTermObject(){
            return new WeightedPodAffinityTermObjectNestedImpl();
    }

    public WatchEventFluent.WeightedPodAffinityTermObjectNested withNewWeightedPodAffinityTermObjectLike(WeightedPodAffinityTerm item){
            return new WeightedPodAffinityTermObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PipelineObjectNested withNewPipelineObject(){
            return new PipelineObjectNestedImpl();
    }

    public WatchEventFluent.PipelineObjectNested withNewPipelineObjectLike(Pipeline item){
            return new PipelineObjectNestedImpl(item);
    }

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

    public WatchEventFluent.NodeListObjectNested withNewNodeListObject(){
            return new NodeListObjectNestedImpl();
    }

    public WatchEventFluent.NodeListObjectNested withNewNodeListObjectLike(NodeList item){
            return new NodeListObjectNestedImpl(item);
    }

    public A withCinderVolumeSourceObject(CinderVolumeSource cinderVolumeSourceObject){
            _visitables.remove(this.object);
            if (cinderVolumeSourceObject!=null){ this.object= new CinderVolumeSourceBuilder(cinderVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CinderVolumeSourceObjectNested withNewCinderVolumeSourceObject(){
            return new CinderVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.CinderVolumeSourceObjectNested withNewCinderVolumeSourceObjectLike(CinderVolumeSource item){
            return new CinderVolumeSourceObjectNestedImpl(item);
    }

    public A withNewCinderVolumeSourceObject(String fsType,Boolean readOnly,String volumeID){
            return (A)withCinderVolumeSourceObject(new CinderVolumeSource(fsType, readOnly, volumeID));
    }

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

    public WatchEventFluent.CustomResourceDefinitionStatusObjectNested withNewCustomResourceDefinitionStatusObject(){
            return new CustomResourceDefinitionStatusObjectNestedImpl();
    }

    public WatchEventFluent.CustomResourceDefinitionStatusObjectNested withNewCustomResourceDefinitionStatusObjectLike(CustomResourceDefinitionStatus item){
            return new CustomResourceDefinitionStatusObjectNestedImpl(item);
    }

    public A withNetworkPolicySpecObject(NetworkPolicySpec networkPolicySpecObject){
            _visitables.remove(this.object);
            if (networkPolicySpecObject!=null){ this.object= new NetworkPolicySpecBuilder(networkPolicySpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NetworkPolicySpecObjectNested withNewNetworkPolicySpecObject(){
            return new NetworkPolicySpecObjectNestedImpl();
    }

    public WatchEventFluent.NetworkPolicySpecObjectNested withNewNetworkPolicySpecObjectLike(NetworkPolicySpec item){
            return new NetworkPolicySpecObjectNestedImpl(item);
    }

    public A withLocalVolumeSourceObject(LocalVolumeSource localVolumeSourceObject){
            _visitables.remove(this.object);
            if (localVolumeSourceObject!=null){ this.object= new LocalVolumeSourceBuilder(localVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LocalVolumeSourceObjectNested withNewLocalVolumeSourceObject(){
            return new LocalVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.LocalVolumeSourceObjectNested withNewLocalVolumeSourceObjectLike(LocalVolumeSource item){
            return new LocalVolumeSourceObjectNestedImpl(item);
    }

    public A withNewLocalVolumeSourceObject(String path){
            return (A)withLocalVolumeSourceObject(new LocalVolumeSource(path));
    }

    public A withResourceQuotaObject(ResourceQuota resourceQuotaObject){
            _visitables.remove(this.object);
            if (resourceQuotaObject!=null){ this.object= new ResourceQuotaBuilder(resourceQuotaObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceQuotaObjectNested withNewResourceQuotaObject(){
            return new ResourceQuotaObjectNestedImpl();
    }

    public WatchEventFluent.ResourceQuotaObjectNested withNewResourceQuotaObjectLike(ResourceQuota item){
            return new ResourceQuotaObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PodListObjectNested withNewPodListObject(){
            return new PodListObjectNestedImpl();
    }

    public WatchEventFluent.PodListObjectNested withNewPodListObjectLike(PodList item){
            return new PodListObjectNestedImpl(item);
    }

    public A withUserInfoObject(UserInfo userInfoObject){
            _visitables.remove(this.object);
            if (userInfoObject!=null){ this.object= new UserInfoBuilder(userInfoObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.UserInfoObjectNested withNewUserInfoObject(){
            return new UserInfoObjectNestedImpl();
    }

    public WatchEventFluent.UserInfoObjectNested withNewUserInfoObjectLike(UserInfo item){
            return new UserInfoObjectNestedImpl(item);
    }

    public A withPipelineSourceSvnObject(PipelineSourceSvn pipelineSourceSvnObject){
            _visitables.remove(this.object);
            if (pipelineSourceSvnObject!=null){ this.object= new PipelineSourceSvnBuilder(pipelineSourceSvnObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineSourceSvnObjectNested withNewPipelineSourceSvnObject(){
            return new PipelineSourceSvnObjectNestedImpl();
    }

    public WatchEventFluent.PipelineSourceSvnObjectNested withNewPipelineSourceSvnObjectLike(PipelineSourceSvn item){
            return new PipelineSourceSvnObjectNestedImpl(item);
    }

    public A withNewPipelineSourceSvnObject(String uri){
            return (A)withPipelineSourceSvnObject(new PipelineSourceSvn(uri));
    }

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

    public WatchEventFluent.CustomResourceDefinitionSpecObjectNested withNewCustomResourceDefinitionSpecObject(){
            return new CustomResourceDefinitionSpecObjectNestedImpl();
    }

    public WatchEventFluent.CustomResourceDefinitionSpecObjectNested withNewCustomResourceDefinitionSpecObjectLike(CustomResourceDefinitionSpec item){
            return new CustomResourceDefinitionSpecObjectNestedImpl(item);
    }

    public A withCodeRepositoryStatusObject(CodeRepositoryStatus codeRepositoryStatusObject){
            _visitables.remove(this.object);
            if (codeRepositoryStatusObject!=null){ this.object= new CodeRepositoryStatusBuilder(codeRepositoryStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositoryStatusObjectNested withNewCodeRepositoryStatusObject(){
            return new CodeRepositoryStatusObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositoryStatusObjectNested withNewCodeRepositoryStatusObjectLike(CodeRepositoryStatus item){
            return new CodeRepositoryStatusObjectNestedImpl(item);
    }

    public A withAzureFileVolumeSourceObject(AzureFileVolumeSource azureFileVolumeSourceObject){
            _visitables.remove(this.object);
            if (azureFileVolumeSourceObject!=null){ this.object= new AzureFileVolumeSourceBuilder(azureFileVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AzureFileVolumeSourceObjectNested withNewAzureFileVolumeSourceObject(){
            return new AzureFileVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.AzureFileVolumeSourceObjectNested withNewAzureFileVolumeSourceObjectLike(AzureFileVolumeSource item){
            return new AzureFileVolumeSourceObjectNestedImpl(item);
    }

    public A withNewAzureFileVolumeSourceObject(Boolean readOnly,String secretName,String shareName){
            return (A)withAzureFileVolumeSourceObject(new AzureFileVolumeSource(readOnly, secretName, shareName));
    }

    public A withCodeRepoServiceSpecObject(CodeRepoServiceSpec codeRepoServiceSpecObject){
            _visitables.remove(this.object);
            if (codeRepoServiceSpecObject!=null){ this.object= new CodeRepoServiceSpecBuilder(codeRepoServiceSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoServiceSpecObjectNested withNewCodeRepoServiceSpecObject(){
            return new CodeRepoServiceSpecObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoServiceSpecObjectNested withNewCodeRepoServiceSpecObjectLike(CodeRepoServiceSpec item){
            return new CodeRepoServiceSpecObjectNestedImpl(item);
    }

    public A withServiceAccountObject(ServiceAccount serviceAccountObject){
            _visitables.remove(this.object);
            if (serviceAccountObject!=null){ this.object= new ServiceAccountBuilder(serviceAccountObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServiceAccountObjectNested withNewServiceAccountObject(){
            return new ServiceAccountObjectNestedImpl();
    }

    public WatchEventFluent.ServiceAccountObjectNested withNewServiceAccountObjectLike(ServiceAccount item){
            return new ServiceAccountObjectNestedImpl(item);
    }

    public A withCodeRepoBindingSpecObject(CodeRepoBindingSpec codeRepoBindingSpecObject){
            _visitables.remove(this.object);
            if (codeRepoBindingSpecObject!=null){ this.object= new CodeRepoBindingSpecBuilder(codeRepoBindingSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoBindingSpecObjectNested withNewCodeRepoBindingSpecObject(){
            return new CodeRepoBindingSpecObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoBindingSpecObjectNested withNewCodeRepoBindingSpecObjectLike(CodeRepoBindingSpec item){
            return new CodeRepoBindingSpecObjectNestedImpl(item);
    }

    public A withStorageOSPersistentVolumeSourceObject(StorageOSPersistentVolumeSource storageOSPersistentVolumeSourceObject){
            _visitables.remove(this.object);
            if (storageOSPersistentVolumeSourceObject!=null){ this.object= new StorageOSPersistentVolumeSourceBuilder(storageOSPersistentVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested withNewStorageOSPersistentVolumeSourceObject(){
            return new StorageOSPersistentVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested withNewStorageOSPersistentVolumeSourceObjectLike(StorageOSPersistentVolumeSource item){
            return new StorageOSPersistentVolumeSourceObjectNestedImpl(item);
    }

    public A withLimitRangeSpecObject(LimitRangeSpec limitRangeSpecObject){
            _visitables.remove(this.object);
            if (limitRangeSpecObject!=null){ this.object= new LimitRangeSpecBuilder(limitRangeSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LimitRangeSpecObjectNested withNewLimitRangeSpecObject(){
            return new LimitRangeSpecObjectNestedImpl();
    }

    public WatchEventFluent.LimitRangeSpecObjectNested withNewLimitRangeSpecObjectLike(LimitRangeSpec item){
            return new LimitRangeSpecObjectNestedImpl(item);
    }

    public A withPipelineStageInstanceObject(PipelineStageInstance pipelineStageInstanceObject){
            _visitables.remove(this.object);
            if (pipelineStageInstanceObject!=null){ this.object= new PipelineStageInstanceBuilder(pipelineStageInstanceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineStageInstanceObjectNested withNewPipelineStageInstanceObject(){
            return new PipelineStageInstanceObjectNestedImpl();
    }

    public WatchEventFluent.PipelineStageInstanceObjectNested withNewPipelineStageInstanceObjectLike(PipelineStageInstance item){
            return new PipelineStageInstanceObjectNestedImpl(item);
    }

    public A withProjectListObject(ProjectList projectListObject){
            _visitables.remove(this.object);
            if (projectListObject!=null){ this.object= new ProjectListBuilder(projectListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectListObjectNested withNewProjectListObject(){
            return new ProjectListObjectNestedImpl();
    }

    public WatchEventFluent.ProjectListObjectNested withNewProjectListObjectLike(ProjectList item){
            return new ProjectListObjectNestedImpl(item);
    }

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

    public WatchEventFluent.ConfigMapObjectNested withNewConfigMapObject(){
            return new ConfigMapObjectNestedImpl();
    }

    public WatchEventFluent.ConfigMapObjectNested withNewConfigMapObjectLike(ConfigMap item){
            return new ConfigMapObjectNestedImpl(item);
    }

    public A withPipelineCauseObject(PipelineCause pipelineCauseObject){
            _visitables.remove(this.object);
            if (pipelineCauseObject!=null){ this.object= new PipelineCauseBuilder(pipelineCauseObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineCauseObjectNested withNewPipelineCauseObject(){
            return new PipelineCauseObjectNestedImpl();
    }

    public WatchEventFluent.PipelineCauseObjectNested withNewPipelineCauseObjectLike(PipelineCause item){
            return new PipelineCauseObjectNestedImpl(item);
    }

    public A withNewPipelineCauseObject(String message,String type){
            return (A)withPipelineCauseObject(new PipelineCause(message, type));
    }

    public A withVolumeObject(Volume volumeObject){
            _visitables.remove(this.object);
            if (volumeObject!=null){ this.object= new VolumeBuilder(volumeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.VolumeObjectNested withNewVolumeObject(){
            return new VolumeObjectNestedImpl();
    }

    public WatchEventFluent.VolumeObjectNested withNewVolumeObjectLike(Volume item){
            return new VolumeObjectNestedImpl(item);
    }

    public A withFSGroupStrategyOptionsObject(FSGroupStrategyOptions fSGroupStrategyOptionsObject){
            _visitables.remove(this.object);
            if (fSGroupStrategyOptionsObject!=null){ this.object= new FSGroupStrategyOptionsBuilder(fSGroupStrategyOptionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.FSGroupStrategyOptionsObjectNested withNewFSGroupStrategyOptionsObject(){
            return new FSGroupStrategyOptionsObjectNestedImpl();
    }

    public WatchEventFluent.FSGroupStrategyOptionsObjectNested withNewFSGroupStrategyOptionsObjectLike(FSGroupStrategyOptions item){
            return new FSGroupStrategyOptionsObjectNestedImpl(item);
    }

    public A withPipelineStatusJenkinsObject(PipelineStatusJenkins pipelineStatusJenkinsObject){
            _visitables.remove(this.object);
            if (pipelineStatusJenkinsObject!=null){ this.object= new PipelineStatusJenkinsBuilder(pipelineStatusJenkinsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineStatusJenkinsObjectNested withNewPipelineStatusJenkinsObject(){
            return new PipelineStatusJenkinsObjectNestedImpl();
    }

    public WatchEventFluent.PipelineStatusJenkinsObjectNested withNewPipelineStatusJenkinsObjectLike(PipelineStatusJenkins item){
            return new PipelineStatusJenkinsObjectNestedImpl(item);
    }

    public A withNewPipelineStatusJenkinsObject(String build,String result,String stages,String startStageID,String status){
            return (A)withPipelineStatusJenkinsObject(new PipelineStatusJenkins(build, result, stages, startStageID, status));
    }

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

    public WatchEventFluent.JenkinsBindingObjectNested withNewJenkinsBindingObject(){
            return new JenkinsBindingObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsBindingObjectNested withNewJenkinsBindingObjectLike(JenkinsBinding item){
            return new JenkinsBindingObjectNestedImpl(item);
    }

    public A withPipelineTemplateObject(PipelineTemplate pipelineTemplateObject){
            _visitables.remove(this.object);
            if (pipelineTemplateObject!=null){ this.object= new PipelineTemplateBuilder(pipelineTemplateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateObjectNested withNewPipelineTemplateObject(){
            return new PipelineTemplateObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateObjectNested withNewPipelineTemplateObjectLike(PipelineTemplate item){
            return new PipelineTemplateObjectNestedImpl(item);
    }

    public A withNodeAffinityObject(NodeAffinity nodeAffinityObject){
            _visitables.remove(this.object);
            if (nodeAffinityObject!=null){ this.object= new NodeAffinityBuilder(nodeAffinityObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeAffinityObjectNested withNewNodeAffinityObject(){
            return new NodeAffinityObjectNestedImpl();
    }

    public WatchEventFluent.NodeAffinityObjectNested withNewNodeAffinityObjectLike(NodeAffinity item){
            return new NodeAffinityObjectNestedImpl(item);
    }

    public A withPipelineConfigStatusObject(PipelineConfigStatus pipelineConfigStatusObject){
            _visitables.remove(this.object);
            if (pipelineConfigStatusObject!=null){ this.object= new PipelineConfigStatusBuilder(pipelineConfigStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineConfigStatusObjectNested withNewPipelineConfigStatusObject(){
            return new PipelineConfigStatusObjectNestedImpl();
    }

    public WatchEventFluent.PipelineConfigStatusObjectNested withNewPipelineConfigStatusObjectLike(PipelineConfigStatus item){
            return new PipelineConfigStatusObjectNestedImpl(item);
    }

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

    public WatchEventFluent.ConfigMapListObjectNested withNewConfigMapListObject(){
            return new ConfigMapListObjectNestedImpl();
    }

    public WatchEventFluent.ConfigMapListObjectNested withNewConfigMapListObjectLike(ConfigMapList item){
            return new ConfigMapListObjectNestedImpl(item);
    }

    public A withPipelineTriggeScheduleObject(PipelineTriggeSchedule pipelineTriggeScheduleObject){
            _visitables.remove(this.object);
            if (pipelineTriggeScheduleObject!=null){ this.object= new PipelineTriggeScheduleBuilder(pipelineTriggeScheduleObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTriggeScheduleObjectNested withNewPipelineTriggeScheduleObject(){
            return new PipelineTriggeScheduleObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTriggeScheduleObjectNested withNewPipelineTriggeScheduleObjectLike(PipelineTriggeSchedule item){
            return new PipelineTriggeScheduleObjectNestedImpl(item);
    }

    public A withPipelineTaskTemplateListObject(PipelineTaskTemplateList pipelineTaskTemplateListObject){
            _visitables.remove(this.object);
            if (pipelineTaskTemplateListObject!=null){ this.object= new PipelineTaskTemplateListBuilder(pipelineTaskTemplateListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskTemplateListObjectNested withNewPipelineTaskTemplateListObject(){
            return new PipelineTaskTemplateListObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskTemplateListObjectNested withNewPipelineTaskTemplateListObjectLike(PipelineTaskTemplateList item){
            return new PipelineTaskTemplateListObjectNestedImpl(item);
    }

    public A withDaemonSetStatusObject(DaemonSetStatus daemonSetStatusObject){
            _visitables.remove(this.object);
            if (daemonSetStatusObject!=null){ this.object= new DaemonSetStatusBuilder(daemonSetStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DaemonSetStatusObjectNested withNewDaemonSetStatusObject(){
            return new DaemonSetStatusObjectNestedImpl();
    }

    public WatchEventFluent.DaemonSetStatusObjectNested withNewDaemonSetStatusObjectLike(DaemonSetStatus item){
            return new DaemonSetStatusObjectNestedImpl(item);
    }

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

    public WatchEventFluent.BaseKubernetesListObjectNested withNewBaseKubernetesListObject(){
            return new BaseKubernetesListObjectNestedImpl();
    }

    public WatchEventFluent.BaseKubernetesListObjectNested withNewBaseKubernetesListObjectLike(BaseKubernetesList item){
            return new BaseKubernetesListObjectNestedImpl(item);
    }

    public A withInitializerObject(Initializer initializerObject){
            _visitables.remove(this.object);
            if (initializerObject!=null){ this.object= new InitializerBuilder(initializerObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.InitializerObjectNested withNewInitializerObject(){
            return new InitializerObjectNestedImpl();
    }

    public WatchEventFluent.InitializerObjectNested withNewInitializerObjectLike(Initializer item){
            return new InitializerObjectNestedImpl(item);
    }

    public A withNewInitializerObject(String name){
            return (A)withInitializerObject(new Initializer(name));
    }

    public A withStatusObject(Status statusObject){
            _visitables.remove(this.object);
            if (statusObject!=null){ this.object= new StatusBuilder(statusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatusObjectNested withNewStatusObject(){
            return new StatusObjectNestedImpl();
    }

    public WatchEventFluent.StatusObjectNested withNewStatusObjectLike(Status item){
            return new StatusObjectNestedImpl(item);
    }

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

    public WatchEventFluent.CronJobObjectNested withNewCronJobObject(){
            return new CronJobObjectNestedImpl();
    }

    public WatchEventFluent.CronJobObjectNested withNewCronJobObjectLike(CronJob item){
            return new CronJobObjectNestedImpl(item);
    }

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

    public WatchEventFluent.ListMetaObjectNested withNewListMetaObject(){
            return new ListMetaObjectNestedImpl();
    }

    public WatchEventFluent.ListMetaObjectNested withNewListMetaObjectLike(ListMeta item){
            return new ListMetaObjectNestedImpl(item);
    }

    public A withNewListMetaObject(String resourceVersion,String selfLink){
            return (A)withListMetaObject(new ListMeta(resourceVersion, selfLink));
    }

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

    public WatchEventFluent.ComponentStatusListObjectNested withNewComponentStatusListObject(){
            return new ComponentStatusListObjectNestedImpl();
    }

    public WatchEventFluent.ComponentStatusListObjectNested withNewComponentStatusListObjectLike(ComponentStatusList item){
            return new ComponentStatusListObjectNestedImpl(item);
    }

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

    public WatchEventFluent.JenkinsBindingListObjectNested withNewJenkinsBindingListObject(){
            return new JenkinsBindingListObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsBindingListObjectNested withNewJenkinsBindingListObjectLike(JenkinsBindingList item){
            return new JenkinsBindingListObjectNestedImpl(item);
    }

    public A withBindingConditionObject(BindingCondition bindingConditionObject){
            _visitables.remove(this.object);
            if (bindingConditionObject!=null){ this.object= new BindingConditionBuilder(bindingConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.BindingConditionObjectNested withNewBindingConditionObject(){
            return new BindingConditionObjectNestedImpl();
    }

    public WatchEventFluent.BindingConditionObjectNested withNewBindingConditionObjectLike(BindingCondition item){
            return new BindingConditionObjectNestedImpl(item);
    }

    public A withNodeStatusObject(NodeStatus nodeStatusObject){
            _visitables.remove(this.object);
            if (nodeStatusObject!=null){ this.object= new NodeStatusBuilder(nodeStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeStatusObjectNested withNewNodeStatusObject(){
            return new NodeStatusObjectNestedImpl();
    }

    public WatchEventFluent.NodeStatusObjectNested withNewNodeStatusObjectLike(NodeStatus item){
            return new NodeStatusObjectNestedImpl(item);
    }

    public A withGlobalParameterObject(GlobalParameter globalParameterObject){
            _visitables.remove(this.object);
            if (globalParameterObject!=null){ this.object= new GlobalParameterBuilder(globalParameterObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.GlobalParameterObjectNested withNewGlobalParameterObject(){
            return new GlobalParameterObjectNestedImpl();
    }

    public WatchEventFluent.GlobalParameterObjectNested withNewGlobalParameterObjectLike(GlobalParameter item){
            return new GlobalParameterObjectNestedImpl(item);
    }

    public A withTokenReviewSpecObject(TokenReviewSpec tokenReviewSpecObject){
            _visitables.remove(this.object);
            if (tokenReviewSpecObject!=null){ this.object= new TokenReviewSpecBuilder(tokenReviewSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.TokenReviewSpecObjectNested withNewTokenReviewSpecObject(){
            return new TokenReviewSpecObjectNestedImpl();
    }

    public WatchEventFluent.TokenReviewSpecObjectNested withNewTokenReviewSpecObjectLike(TokenReviewSpec item){
            return new TokenReviewSpecObjectNestedImpl(item);
    }

    public A withNewTokenReviewSpecObject(String token){
            return (A)withTokenReviewSpecObject(new TokenReviewSpec(token));
    }

    public A withPipelineEnvironmentObject(PipelineEnvironment pipelineEnvironmentObject){
            _visitables.remove(this.object);
            if (pipelineEnvironmentObject!=null){ this.object= new PipelineEnvironmentBuilder(pipelineEnvironmentObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineEnvironmentObjectNested withNewPipelineEnvironmentObject(){
            return new PipelineEnvironmentObjectNestedImpl();
    }

    public WatchEventFluent.PipelineEnvironmentObjectNested withNewPipelineEnvironmentObjectLike(PipelineEnvironment item){
            return new PipelineEnvironmentObjectNestedImpl(item);
    }

    public A withNewPipelineEnvironmentObject(String name,String value){
            return (A)withPipelineEnvironmentObject(new PipelineEnvironment(name, value));
    }

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

    public WatchEventFluent.EventListObjectNested withNewEventListObject(){
            return new EventListObjectNestedImpl();
    }

    public WatchEventFluent.EventListObjectNested withNewEventListObjectLike(EventList item){
            return new EventListObjectNestedImpl(item);
    }

    public A withVolumeMountObject(VolumeMount volumeMountObject){
            _visitables.remove(this.object);
            if (volumeMountObject!=null){ this.object= new VolumeMountBuilder(volumeMountObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.VolumeMountObjectNested withNewVolumeMountObject(){
            return new VolumeMountObjectNestedImpl();
    }

    public WatchEventFluent.VolumeMountObjectNested withNewVolumeMountObjectLike(VolumeMount item){
            return new VolumeMountObjectNestedImpl(item);
    }

    public A withNewVolumeMountObject(String mountPath,String name,Boolean readOnly,String subPath){
            return (A)withVolumeMountObject(new VolumeMount(mountPath, name, readOnly, subPath));
    }

    public A withSubjectAccessReviewObject(SubjectAccessReview subjectAccessReviewObject){
            _visitables.remove(this.object);
            if (subjectAccessReviewObject!=null){ this.object= new SubjectAccessReviewBuilder(subjectAccessReviewObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SubjectAccessReviewObjectNested withNewSubjectAccessReviewObject(){
            return new SubjectAccessReviewObjectNestedImpl();
    }

    public WatchEventFluent.SubjectAccessReviewObjectNested withNewSubjectAccessReviewObjectLike(SubjectAccessReview item){
            return new SubjectAccessReviewObjectNestedImpl(item);
    }

    public A withSELinuxOptionsObject(SELinuxOptions sELinuxOptionsObject){
            _visitables.remove(this.object);
            if (sELinuxOptionsObject!=null){ this.object= new SELinuxOptionsBuilder(sELinuxOptionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SELinuxOptionsObjectNested withNewSELinuxOptionsObject(){
            return new SELinuxOptionsObjectNestedImpl();
    }

    public WatchEventFluent.SELinuxOptionsObjectNested withNewSELinuxOptionsObjectLike(SELinuxOptions item){
            return new SELinuxOptionsObjectNestedImpl(item);
    }

    public A withNewSELinuxOptionsObject(String level,String role,String type,String user){
            return (A)withSELinuxOptionsObject(new SELinuxOptions(level, role, type, user));
    }

    public A withDeploymentSpecObject(DeploymentSpec deploymentSpecObject){
            _visitables.remove(this.object);
            if (deploymentSpecObject!=null){ this.object= new DeploymentSpecBuilder(deploymentSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DeploymentSpecObjectNested withNewDeploymentSpecObject(){
            return new DeploymentSpecObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentSpecObjectNested withNewDeploymentSpecObjectLike(DeploymentSpec item){
            return new DeploymentSpecObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PersistentVolumeClaimListObjectNested withNewPersistentVolumeClaimListObject(){
            return new PersistentVolumeClaimListObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeClaimListObjectNested withNewPersistentVolumeClaimListObjectLike(PersistentVolumeClaimList item){
            return new PersistentVolumeClaimListObjectNestedImpl(item);
    }

    public A withPodTemplateObject(PodTemplate podTemplateObject){
            _visitables.remove(this.object);
            if (podTemplateObject!=null){ this.object= new PodTemplateBuilder(podTemplateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodTemplateObjectNested withNewPodTemplateObject(){
            return new PodTemplateObjectNestedImpl();
    }

    public WatchEventFluent.PodTemplateObjectNested withNewPodTemplateObjectLike(PodTemplate item){
            return new PodTemplateObjectNestedImpl(item);
    }

    public A withFCVolumeSourceObject(FCVolumeSource fCVolumeSourceObject){
            _visitables.remove(this.object);
            if (fCVolumeSourceObject!=null){ this.object= new FCVolumeSourceBuilder(fCVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.FCVolumeSourceObjectNested withNewFCVolumeSourceObject(){
            return new FCVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.FCVolumeSourceObjectNested withNewFCVolumeSourceObjectLike(FCVolumeSource item){
            return new FCVolumeSourceObjectNestedImpl(item);
    }

    public A withPipelineStatusObject(PipelineStatus pipelineStatusObject){
            _visitables.remove(this.object);
            if (pipelineStatusObject!=null){ this.object= new PipelineStatusBuilder(pipelineStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineStatusObjectNested withNewPipelineStatusObject(){
            return new PipelineStatusObjectNestedImpl();
    }

    public WatchEventFluent.PipelineStatusObjectNested withNewPipelineStatusObjectLike(PipelineStatus item){
            return new PipelineStatusObjectNestedImpl(item);
    }

    public A withPipelineTemplateArgumentValueObject(PipelineTemplateArgumentValue pipelineTemplateArgumentValueObject){
            _visitables.remove(this.object);
            if (pipelineTemplateArgumentValueObject!=null){ this.object= new PipelineTemplateArgumentValueBuilder(pipelineTemplateArgumentValueObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateArgumentValueObjectNested withNewPipelineTemplateArgumentValueObject(){
            return new PipelineTemplateArgumentValueObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateArgumentValueObjectNested withNewPipelineTemplateArgumentValueObjectLike(PipelineTemplateArgumentValue item){
            return new PipelineTemplateArgumentValueObjectNestedImpl(item);
    }

    public A withDaemonSetSpecObject(DaemonSetSpec daemonSetSpecObject){
            _visitables.remove(this.object);
            if (daemonSetSpecObject!=null){ this.object= new DaemonSetSpecBuilder(daemonSetSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DaemonSetSpecObjectNested withNewDaemonSetSpecObject(){
            return new DaemonSetSpecObjectNestedImpl();
    }

    public WatchEventFluent.DaemonSetSpecObjectNested withNewDaemonSetSpecObjectLike(DaemonSetSpec item){
            return new DaemonSetSpecObjectNestedImpl(item);
    }

    public A withPipelineStrategyObject(PipelineStrategy pipelineStrategyObject){
            _visitables.remove(this.object);
            if (pipelineStrategyObject!=null){ this.object= new PipelineStrategyBuilder(pipelineStrategyObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineStrategyObjectNested withNewPipelineStrategyObject(){
            return new PipelineStrategyObjectNestedImpl();
    }

    public WatchEventFluent.PipelineStrategyObjectNested withNewPipelineStrategyObjectLike(PipelineStrategy item){
            return new PipelineStrategyObjectNestedImpl(item);
    }

    public A withConditionObject(Condition conditionObject){
            _visitables.remove(this.object);
            if (conditionObject!=null){ this.object= new ConditionBuilder(conditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ConditionObjectNested withNewConditionObject(){
            return new ConditionObjectNestedImpl();
    }

    public WatchEventFluent.ConditionObjectNested withNewConditionObjectLike(Condition item){
            return new ConditionObjectNestedImpl(item);
    }

    public A withNewConditionObject(String lastAttempt,String message,String reason,String status,String type){
            return (A)withConditionObject(new Condition(lastAttempt, message, reason, status, type));
    }

    public A withContainerStateWaitingObject(ContainerStateWaiting containerStateWaitingObject){
            _visitables.remove(this.object);
            if (containerStateWaitingObject!=null){ this.object= new ContainerStateWaitingBuilder(containerStateWaitingObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerStateWaitingObjectNested withNewContainerStateWaitingObject(){
            return new ContainerStateWaitingObjectNestedImpl();
    }

    public WatchEventFluent.ContainerStateWaitingObjectNested withNewContainerStateWaitingObjectLike(ContainerStateWaiting item){
            return new ContainerStateWaitingObjectNestedImpl(item);
    }

    public A withNewContainerStateWaitingObject(String message,String reason){
            return (A)withContainerStateWaitingObject(new ContainerStateWaiting(message, reason));
    }

    public A withTokenReviewObject(TokenReview tokenReviewObject){
            _visitables.remove(this.object);
            if (tokenReviewObject!=null){ this.object= new TokenReviewBuilder(tokenReviewObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.TokenReviewObjectNested withNewTokenReviewObject(){
            return new TokenReviewObjectNestedImpl();
    }

    public WatchEventFluent.TokenReviewObjectNested withNewTokenReviewObjectLike(TokenReview item){
            return new TokenReviewObjectNestedImpl(item);
    }

    public A withScaleSpecObject(ScaleSpec scaleSpecObject){
            _visitables.remove(this.object);
            if (scaleSpecObject!=null){ this.object= new ScaleSpecBuilder(scaleSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ScaleSpecObjectNested withNewScaleSpecObject(){
            return new ScaleSpecObjectNestedImpl();
    }

    public WatchEventFluent.ScaleSpecObjectNested withNewScaleSpecObjectLike(ScaleSpec item){
            return new ScaleSpecObjectNestedImpl(item);
    }

    public A withNewScaleSpecObject(Integer replicas){
            return (A)withScaleSpecObject(new ScaleSpec(replicas));
    }

    public A withCodeRepoBindingListObject(CodeRepoBindingList codeRepoBindingListObject){
            _visitables.remove(this.object);
            if (codeRepoBindingListObject!=null){ this.object= new CodeRepoBindingListBuilder(codeRepoBindingListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoBindingListObjectNested withNewCodeRepoBindingListObject(){
            return new CodeRepoBindingListObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoBindingListObjectNested withNewCodeRepoBindingListObjectLike(CodeRepoBindingList item){
            return new CodeRepoBindingListObjectNestedImpl(item);
    }

    public A withNetworkPolicyPeerObject(NetworkPolicyPeer networkPolicyPeerObject){
            _visitables.remove(this.object);
            if (networkPolicyPeerObject!=null){ this.object= new NetworkPolicyPeerBuilder(networkPolicyPeerObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NetworkPolicyPeerObjectNested withNewNetworkPolicyPeerObject(){
            return new NetworkPolicyPeerObjectNestedImpl();
    }

    public WatchEventFluent.NetworkPolicyPeerObjectNested withNewNetworkPolicyPeerObjectLike(NetworkPolicyPeer item){
            return new NetworkPolicyPeerObjectNestedImpl(item);
    }

    public A withPreferencesObject(Preferences preferencesObject){
            _visitables.remove(this.object);
            if (preferencesObject!=null){ this.object= new PreferencesBuilder(preferencesObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PreferencesObjectNested withNewPreferencesObject(){
            return new PreferencesObjectNestedImpl();
    }

    public WatchEventFluent.PreferencesObjectNested withNewPreferencesObjectLike(Preferences item){
            return new PreferencesObjectNestedImpl(item);
    }

    public A withMultiBranchBehavioursObject(MultiBranchBehaviours multiBranchBehavioursObject){
            _visitables.remove(this.object);
            if (multiBranchBehavioursObject!=null){ this.object= new MultiBranchBehavioursBuilder(multiBranchBehavioursObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.MultiBranchBehavioursObjectNested withNewMultiBranchBehavioursObject(){
            return new MultiBranchBehavioursObjectNestedImpl();
    }

    public WatchEventFluent.MultiBranchBehavioursObjectNested withNewMultiBranchBehavioursObjectLike(MultiBranchBehaviours item){
            return new MultiBranchBehavioursObjectNestedImpl(item);
    }

    public A withNodeDaemonEndpointsObject(NodeDaemonEndpoints nodeDaemonEndpointsObject){
            _visitables.remove(this.object);
            if (nodeDaemonEndpointsObject!=null){ this.object= new NodeDaemonEndpointsBuilder(nodeDaemonEndpointsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeDaemonEndpointsObjectNested withNewNodeDaemonEndpointsObject(){
            return new NodeDaemonEndpointsObjectNestedImpl();
    }

    public WatchEventFluent.NodeDaemonEndpointsObjectNested withNewNodeDaemonEndpointsObjectLike(NodeDaemonEndpoints item){
            return new NodeDaemonEndpointsObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PersistentVolumeListObjectNested withNewPersistentVolumeListObject(){
            return new PersistentVolumeListObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeListObjectNested withNewPersistentVolumeListObjectLike(PersistentVolumeList item){
            return new PersistentVolumeListObjectNestedImpl(item);
    }

    public A withLimitRangeItemObject(LimitRangeItem limitRangeItemObject){
            _visitables.remove(this.object);
            if (limitRangeItemObject!=null){ this.object= new LimitRangeItemBuilder(limitRangeItemObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LimitRangeItemObjectNested withNewLimitRangeItemObject(){
            return new LimitRangeItemObjectNestedImpl();
    }

    public WatchEventFluent.LimitRangeItemObjectNested withNewLimitRangeItemObjectLike(LimitRangeItem item){
            return new LimitRangeItemObjectNestedImpl(item);
    }

    public A withDaemonSetUpdateStrategyObject(DaemonSetUpdateStrategy daemonSetUpdateStrategyObject){
            _visitables.remove(this.object);
            if (daemonSetUpdateStrategyObject!=null){ this.object= new DaemonSetUpdateStrategyBuilder(daemonSetUpdateStrategyObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DaemonSetUpdateStrategyObjectNested withNewDaemonSetUpdateStrategyObject(){
            return new DaemonSetUpdateStrategyObjectNestedImpl();
    }

    public WatchEventFluent.DaemonSetUpdateStrategyObjectNested withNewDaemonSetUpdateStrategyObjectLike(DaemonSetUpdateStrategy item){
            return new DaemonSetUpdateStrategyObjectNestedImpl(item);
    }

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

    public WatchEventFluent.CustomResourceDefinitionObjectNested withNewCustomResourceDefinitionObject(){
            return new CustomResourceDefinitionObjectNestedImpl();
    }

    public WatchEventFluent.CustomResourceDefinitionObjectNested withNewCustomResourceDefinitionObjectLike(CustomResourceDefinition item){
            return new CustomResourceDefinitionObjectNestedImpl(item);
    }

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

    public WatchEventFluent.IngressListObjectNested withNewIngressListObject(){
            return new IngressListObjectNestedImpl();
    }

    public WatchEventFluent.IngressListObjectNested withNewIngressListObjectLike(IngressList item){
            return new IngressListObjectNestedImpl(item);
    }

    public A withFlexVolumeSourceObject(FlexVolumeSource flexVolumeSourceObject){
            _visitables.remove(this.object);
            if (flexVolumeSourceObject!=null){ this.object= new FlexVolumeSourceBuilder(flexVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.FlexVolumeSourceObjectNested withNewFlexVolumeSourceObject(){
            return new FlexVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.FlexVolumeSourceObjectNested withNewFlexVolumeSourceObjectLike(FlexVolumeSource item){
            return new FlexVolumeSourceObjectNestedImpl(item);
    }

    public A withJenkinsAgentObject(JenkinsAgent jenkinsAgentObject){
            _visitables.remove(this.object);
            if (jenkinsAgentObject!=null){ this.object= new JenkinsAgentBuilder(jenkinsAgentObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsAgentObjectNested withNewJenkinsAgentObject(){
            return new JenkinsAgentObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsAgentObjectNested withNewJenkinsAgentObjectLike(JenkinsAgent item){
            return new JenkinsAgentObjectNestedImpl(item);
    }

    public A withNewJenkinsAgentObject(String label){
            return (A)withJenkinsAgentObject(new JenkinsAgent(label));
    }

    public A withDeploymentConditionObject(DeploymentCondition deploymentConditionObject){
            _visitables.remove(this.object);
            if (deploymentConditionObject!=null){ this.object= new DeploymentConditionBuilder(deploymentConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DeploymentConditionObjectNested withNewDeploymentConditionObject(){
            return new DeploymentConditionObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentConditionObjectNested withNewDeploymentConditionObjectLike(DeploymentCondition item){
            return new DeploymentConditionObjectNestedImpl(item);
    }

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

    public WatchEventFluent.ConfigObjectNested withNewConfigObject(){
            return new ConfigObjectNestedImpl();
    }

    public WatchEventFluent.ConfigObjectNested withNewConfigObjectLike(Config item){
            return new ConfigObjectNestedImpl(item);
    }

    public A withPipelineParameterObject(PipelineParameter pipelineParameterObject){
            _visitables.remove(this.object);
            if (pipelineParameterObject!=null){ this.object= new PipelineParameterBuilder(pipelineParameterObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineParameterObjectNested withNewPipelineParameterObject(){
            return new PipelineParameterObjectNestedImpl();
    }

    public WatchEventFluent.PipelineParameterObjectNested withNewPipelineParameterObjectLike(PipelineParameter item){
            return new PipelineParameterObjectNestedImpl(item);
    }

    public A withNewPipelineParameterObject(String description,String name,String type,String value){
            return (A)withPipelineParameterObject(new PipelineParameter(description, name, type, value));
    }

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

    public WatchEventFluent.NamespaceListObjectNested withNewNamespaceListObject(){
            return new NamespaceListObjectNestedImpl();
    }

    public WatchEventFluent.NamespaceListObjectNested withNewNamespaceListObjectLike(NamespaceList item){
            return new NamespaceListObjectNestedImpl(item);
    }

    public A withPodDisruptionBudgetStatusObject(PodDisruptionBudgetStatus podDisruptionBudgetStatusObject){
            _visitables.remove(this.object);
            if (podDisruptionBudgetStatusObject!=null){ this.object= new PodDisruptionBudgetStatusBuilder(podDisruptionBudgetStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodDisruptionBudgetStatusObjectNested withNewPodDisruptionBudgetStatusObject(){
            return new PodDisruptionBudgetStatusObjectNestedImpl();
    }

    public WatchEventFluent.PodDisruptionBudgetStatusObjectNested withNewPodDisruptionBudgetStatusObjectLike(PodDisruptionBudgetStatus item){
            return new PodDisruptionBudgetStatusObjectNestedImpl(item);
    }

    public A withCodeRepositorySpecObject(CodeRepositorySpec codeRepositorySpecObject){
            _visitables.remove(this.object);
            if (codeRepositorySpecObject!=null){ this.object= new CodeRepositorySpecBuilder(codeRepositorySpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositorySpecObjectNested withNewCodeRepositorySpecObject(){
            return new CodeRepositorySpecObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositorySpecObjectNested withNewCodeRepositorySpecObjectLike(CodeRepositorySpec item){
            return new CodeRepositorySpecObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PodDisruptionBudgetListObjectNested withNewPodDisruptionBudgetListObject(){
            return new PodDisruptionBudgetListObjectNestedImpl();
    }

    public WatchEventFluent.PodDisruptionBudgetListObjectNested withNewPodDisruptionBudgetListObjectLike(PodDisruptionBudgetList item){
            return new PodDisruptionBudgetListObjectNestedImpl(item);
    }

    public A withDeploymentStatusObject(DeploymentStatus deploymentStatusObject){
            _visitables.remove(this.object);
            if (deploymentStatusObject!=null){ this.object= new DeploymentStatusBuilder(deploymentStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DeploymentStatusObjectNested withNewDeploymentStatusObject(){
            return new DeploymentStatusObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentStatusObjectNested withNewDeploymentStatusObjectLike(DeploymentStatus item){
            return new DeploymentStatusObjectNestedImpl(item);
    }

    public A withStorageClassObject(StorageClass storageClassObject){
            _visitables.remove(this.object);
            if (storageClassObject!=null){ this.object= new StorageClassBuilder(storageClassObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StorageClassObjectNested withNewStorageClassObject(){
            return new StorageClassObjectNestedImpl();
    }

    public WatchEventFluent.StorageClassObjectNested withNewStorageClassObjectLike(StorageClass item){
            return new StorageClassObjectNestedImpl(item);
    }

    public A withUserAccountObject(UserAccount userAccountObject){
            _visitables.remove(this.object);
            if (userAccountObject!=null){ this.object= new UserAccountBuilder(userAccountObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.UserAccountObjectNested withNewUserAccountObject(){
            return new UserAccountObjectNestedImpl();
    }

    public WatchEventFluent.UserAccountObjectNested withNewUserAccountObjectLike(UserAccount item){
            return new UserAccountObjectNestedImpl(item);
    }

    public A withQuobyteVolumeSourceObject(QuobyteVolumeSource quobyteVolumeSourceObject){
            _visitables.remove(this.object);
            if (quobyteVolumeSourceObject!=null){ this.object= new QuobyteVolumeSourceBuilder(quobyteVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.QuobyteVolumeSourceObjectNested withNewQuobyteVolumeSourceObject(){
            return new QuobyteVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.QuobyteVolumeSourceObjectNested withNewQuobyteVolumeSourceObjectLike(QuobyteVolumeSource item){
            return new QuobyteVolumeSourceObjectNestedImpl(item);
    }

    public A withNewQuobyteVolumeSourceObject(String group,Boolean readOnly,String registry,String user,String volume){
            return (A)withQuobyteVolumeSourceObject(new QuobyteVolumeSource(group, readOnly, registry, user, volume));
    }

    public A withMultiBranchOrphanObject(MultiBranchOrphan multiBranchOrphanObject){
            _visitables.remove(this.object);
            if (multiBranchOrphanObject!=null){ this.object= new MultiBranchOrphanBuilder(multiBranchOrphanObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.MultiBranchOrphanObjectNested withNewMultiBranchOrphanObject(){
            return new MultiBranchOrphanObjectNestedImpl();
    }

    public WatchEventFluent.MultiBranchOrphanObjectNested withNewMultiBranchOrphanObjectLike(MultiBranchOrphan item){
            return new MultiBranchOrphanObjectNestedImpl(item);
    }

    public A withNewMultiBranchOrphanObject(Integer days,Integer max){
            return (A)withMultiBranchOrphanObject(new MultiBranchOrphan(days, max));
    }

    public A withPreferredSchedulingTermObject(PreferredSchedulingTerm preferredSchedulingTermObject){
            _visitables.remove(this.object);
            if (preferredSchedulingTermObject!=null){ this.object= new PreferredSchedulingTermBuilder(preferredSchedulingTermObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PreferredSchedulingTermObjectNested withNewPreferredSchedulingTermObject(){
            return new PreferredSchedulingTermObjectNestedImpl();
    }

    public WatchEventFluent.PreferredSchedulingTermObjectNested withNewPreferredSchedulingTermObjectLike(PreferredSchedulingTerm item){
            return new PreferredSchedulingTermObjectNestedImpl(item);
    }

    public A withHostPortRangeObject(HostPortRange hostPortRangeObject){
            _visitables.remove(this.object);
            if (hostPortRangeObject!=null){ this.object= new HostPortRangeBuilder(hostPortRangeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HostPortRangeObjectNested withNewHostPortRangeObject(){
            return new HostPortRangeObjectNestedImpl();
    }

    public WatchEventFluent.HostPortRangeObjectNested withNewHostPortRangeObjectLike(HostPortRange item){
            return new HostPortRangeObjectNestedImpl(item);
    }

    public A withNewHostPortRangeObject(Integer max,Integer min){
            return (A)withHostPortRangeObject(new HostPortRange(max, min));
    }

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

    public WatchEventFluent.PodSecurityPolicyListObjectNested withNewPodSecurityPolicyListObject(){
            return new PodSecurityPolicyListObjectNestedImpl();
    }

    public WatchEventFluent.PodSecurityPolicyListObjectNested withNewPodSecurityPolicyListObjectLike(PodSecurityPolicyList item){
            return new PodSecurityPolicyListObjectNestedImpl(item);
    }

    public A withReplicationControllerSpecObject(ReplicationControllerSpec replicationControllerSpecObject){
            _visitables.remove(this.object);
            if (replicationControllerSpecObject!=null){ this.object= new ReplicationControllerSpecBuilder(replicationControllerSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicationControllerSpecObjectNested withNewReplicationControllerSpecObject(){
            return new ReplicationControllerSpecObjectNestedImpl();
    }

    public WatchEventFluent.ReplicationControllerSpecObjectNested withNewReplicationControllerSpecObjectLike(ReplicationControllerSpec item){
            return new ReplicationControllerSpecObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PipelineConfigListObjectNested withNewPipelineConfigListObject(){
            return new PipelineConfigListObjectNestedImpl();
    }

    public WatchEventFluent.PipelineConfigListObjectNested withNewPipelineConfigListObjectLike(PipelineConfigList item){
            return new PipelineConfigListObjectNestedImpl(item);
    }

    public A withPipelineHookHTTPRequestObject(PipelineHookHTTPRequest pipelineHookHTTPRequestObject){
            _visitables.remove(this.object);
            if (pipelineHookHTTPRequestObject!=null){ this.object= new PipelineHookHTTPRequestBuilder(pipelineHookHTTPRequestObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineHookHTTPRequestObjectNested withNewPipelineHookHTTPRequestObject(){
            return new PipelineHookHTTPRequestObjectNestedImpl();
    }

    public WatchEventFluent.PipelineHookHTTPRequestObjectNested withNewPipelineHookHTTPRequestObjectLike(PipelineHookHTTPRequest item){
            return new PipelineHookHTTPRequestObjectNestedImpl(item);
    }

    public A withResourceFieldSelectorObject(ResourceFieldSelector resourceFieldSelectorObject){
            _visitables.remove(this.object);
            if (resourceFieldSelectorObject!=null){ this.object= new ResourceFieldSelectorBuilder(resourceFieldSelectorObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceFieldSelectorObjectNested withNewResourceFieldSelectorObject(){
            return new ResourceFieldSelectorObjectNestedImpl();
    }

    public WatchEventFluent.ResourceFieldSelectorObjectNested withNewResourceFieldSelectorObjectLike(ResourceFieldSelector item){
            return new ResourceFieldSelectorObjectNestedImpl(item);
    }

    public A withHostPathVolumeSourceObject(HostPathVolumeSource hostPathVolumeSourceObject){
            _visitables.remove(this.object);
            if (hostPathVolumeSourceObject!=null){ this.object= new HostPathVolumeSourceBuilder(hostPathVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HostPathVolumeSourceObjectNested withNewHostPathVolumeSourceObject(){
            return new HostPathVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.HostPathVolumeSourceObjectNested withNewHostPathVolumeSourceObjectLike(HostPathVolumeSource item){
            return new HostPathVolumeSourceObjectNestedImpl(item);
    }

    public A withNewHostPathVolumeSourceObject(String path){
            return (A)withHostPathVolumeSourceObject(new HostPathVolumeSource(path));
    }

    public A withSELinuxStrategyOptionsObject(SELinuxStrategyOptions sELinuxStrategyOptionsObject){
            _visitables.remove(this.object);
            if (sELinuxStrategyOptionsObject!=null){ this.object= new SELinuxStrategyOptionsBuilder(sELinuxStrategyOptionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SELinuxStrategyOptionsObjectNested withNewSELinuxStrategyOptionsObject(){
            return new SELinuxStrategyOptionsObjectNestedImpl();
    }

    public WatchEventFluent.SELinuxStrategyOptionsObjectNested withNewSELinuxStrategyOptionsObjectLike(SELinuxStrategyOptions item){
            return new SELinuxStrategyOptionsObjectNestedImpl(item);
    }

    public A withPipelineConfigTemplateObject(PipelineConfigTemplate pipelineConfigTemplateObject){
            _visitables.remove(this.object);
            if (pipelineConfigTemplateObject!=null){ this.object= new PipelineConfigTemplateBuilder(pipelineConfigTemplateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineConfigTemplateObjectNested withNewPipelineConfigTemplateObject(){
            return new PipelineConfigTemplateObjectNestedImpl();
    }

    public WatchEventFluent.PipelineConfigTemplateObjectNested withNewPipelineConfigTemplateObjectLike(PipelineConfigTemplate item){
            return new PipelineConfigTemplateObjectNestedImpl(item);
    }

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

    public WatchEventFluent.ContainerStatusObjectNested withNewContainerStatusObject(){
            return new ContainerStatusObjectNestedImpl();
    }

    public WatchEventFluent.ContainerStatusObjectNested withNewContainerStatusObjectLike(ContainerStatus item){
            return new ContainerStatusObjectNestedImpl(item);
    }

    public A withExecActionObject(ExecAction execActionObject){
            _visitables.remove(this.object);
            if (execActionObject!=null){ this.object= new ExecActionBuilder(execActionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ExecActionObjectNested withNewExecActionObject(){
            return new ExecActionObjectNestedImpl();
    }

    public WatchEventFluent.ExecActionObjectNested withNewExecActionObjectLike(ExecAction item){
            return new ExecActionObjectNestedImpl(item);
    }

    public A withPreconditionsObject(Preconditions preconditionsObject){
            _visitables.remove(this.object);
            if (preconditionsObject!=null){ this.object= new PreconditionsBuilder(preconditionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PreconditionsObjectNested withNewPreconditionsObject(){
            return new PreconditionsObjectNestedImpl();
    }

    public WatchEventFluent.PreconditionsObjectNested withNewPreconditionsObjectLike(Preconditions item){
            return new PreconditionsObjectNestedImpl(item);
    }

    public A withNewPreconditionsObject(String uid){
            return (A)withPreconditionsObject(new Preconditions(uid));
    }

    public A withOwnerInRepositoryObject(OwnerInRepository ownerInRepositoryObject){
            _visitables.remove(this.object);
            if (ownerInRepositoryObject!=null){ this.object= new OwnerInRepositoryBuilder(ownerInRepositoryObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.OwnerInRepositoryObjectNested withNewOwnerInRepositoryObject(){
            return new OwnerInRepositoryObjectNestedImpl();
    }

    public WatchEventFluent.OwnerInRepositoryObjectNested withNewOwnerInRepositoryObjectLike(OwnerInRepository item){
            return new OwnerInRepositoryObjectNestedImpl(item);
    }

    public A withNewOwnerInRepositoryObject(String id,String name,String type){
            return (A)withOwnerInRepositoryObject(new OwnerInRepository(id, name, type));
    }

    public A withClusterPipelineTemplateListObject(ClusterPipelineTemplateList clusterPipelineTemplateListObject){
            _visitables.remove(this.object);
            if (clusterPipelineTemplateListObject!=null){ this.object= new ClusterPipelineTemplateListBuilder(clusterPipelineTemplateListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ClusterPipelineTemplateListObjectNested withNewClusterPipelineTemplateListObject(){
            return new ClusterPipelineTemplateListObjectNestedImpl();
    }

    public WatchEventFluent.ClusterPipelineTemplateListObjectNested withNewClusterPipelineTemplateListObjectLike(ClusterPipelineTemplateList item){
            return new ClusterPipelineTemplateListObjectNestedImpl(item);
    }

    public A withIngressRuleObject(IngressRule ingressRuleObject){
            _visitables.remove(this.object);
            if (ingressRuleObject!=null){ this.object= new IngressRuleBuilder(ingressRuleObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.IngressRuleObjectNested withNewIngressRuleObject(){
            return new IngressRuleObjectNestedImpl();
    }

    public WatchEventFluent.IngressRuleObjectNested withNewIngressRuleObjectLike(IngressRule item){
            return new IngressRuleObjectNestedImpl(item);
    }

    public A withStatefulSetStatusObject(StatefulSetStatus statefulSetStatusObject){
            _visitables.remove(this.object);
            if (statefulSetStatusObject!=null){ this.object= new StatefulSetStatusBuilder(statefulSetStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatefulSetStatusObjectNested withNewStatefulSetStatusObject(){
            return new StatefulSetStatusObjectNestedImpl();
    }

    public WatchEventFluent.StatefulSetStatusObjectNested withNewStatefulSetStatusObjectLike(StatefulSetStatus item){
            return new StatefulSetStatusObjectNestedImpl(item);
    }

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

    public WatchEventFluent.NamespaceObjectNested withNewNamespaceObject(){
            return new NamespaceObjectNestedImpl();
    }

    public WatchEventFluent.NamespaceObjectNested withNewNamespaceObjectLike(Namespace item){
            return new NamespaceObjectNestedImpl(item);
    }

    public A withNodeSelectorObject(NodeSelector nodeSelectorObject){
            _visitables.remove(this.object);
            if (nodeSelectorObject!=null){ this.object= new NodeSelectorBuilder(nodeSelectorObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeSelectorObjectNested withNewNodeSelectorObject(){
            return new NodeSelectorObjectNestedImpl();
    }

    public WatchEventFluent.NodeSelectorObjectNested withNewNodeSelectorObjectLike(NodeSelector item){
            return new NodeSelectorObjectNestedImpl(item);
    }

    public A withJenkinsfilePreviewOptionsObject(JenkinsfilePreviewOptions jenkinsfilePreviewOptionsObject){
            _visitables.remove(this.object);
            if (jenkinsfilePreviewOptionsObject!=null){ this.object= new JenkinsfilePreviewOptionsBuilder(jenkinsfilePreviewOptionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsfilePreviewOptionsObjectNested withNewJenkinsfilePreviewOptionsObject(){
            return new JenkinsfilePreviewOptionsObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsfilePreviewOptionsObjectNested withNewJenkinsfilePreviewOptionsObjectLike(JenkinsfilePreviewOptions item){
            return new JenkinsfilePreviewOptionsObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PipelineListObjectNested withNewPipelineListObject(){
            return new PipelineListObjectNestedImpl();
    }

    public WatchEventFluent.PipelineListObjectNested withNewPipelineListObjectLike(PipelineList item){
            return new PipelineListObjectNestedImpl(item);
    }

    public A withHTTPGetActionObject(HTTPGetAction hTTPGetActionObject){
            _visitables.remove(this.object);
            if (hTTPGetActionObject!=null){ this.object= new HTTPGetActionBuilder(hTTPGetActionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HTTPGetActionObjectNested withNewHTTPGetActionObject(){
            return new HTTPGetActionObjectNestedImpl();
    }

    public WatchEventFluent.HTTPGetActionObjectNested withNewHTTPGetActionObjectLike(HTTPGetAction item){
            return new HTTPGetActionObjectNestedImpl(item);
    }

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

    public WatchEventFluent.EndpointsListObjectNested withNewEndpointsListObject(){
            return new EndpointsListObjectNestedImpl();
    }

    public WatchEventFluent.EndpointsListObjectNested withNewEndpointsListObjectLike(EndpointsList item){
            return new EndpointsListObjectNestedImpl(item);
    }

    public A withJenkinsfilePreviewObject(JenkinsfilePreview jenkinsfilePreviewObject){
            _visitables.remove(this.object);
            if (jenkinsfilePreviewObject!=null){ this.object= new JenkinsfilePreviewBuilder(jenkinsfilePreviewObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsfilePreviewObjectNested withNewJenkinsfilePreviewObject(){
            return new JenkinsfilePreviewObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsfilePreviewObjectNested withNewJenkinsfilePreviewObjectLike(JenkinsfilePreview item){
            return new JenkinsfilePreviewObjectNestedImpl(item);
    }

    public A withNewJenkinsfilePreviewObject(String apiVersion,String jenkinsfile,String kind){
            return (A)withJenkinsfilePreviewObject(new JenkinsfilePreview(apiVersion, jenkinsfile, kind));
    }

    public A withReplicationControllerStatusObject(ReplicationControllerStatus replicationControllerStatusObject){
            _visitables.remove(this.object);
            if (replicationControllerStatusObject!=null){ this.object= new ReplicationControllerStatusBuilder(replicationControllerStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicationControllerStatusObjectNested withNewReplicationControllerStatusObject(){
            return new ReplicationControllerStatusObjectNestedImpl();
    }

    public WatchEventFluent.ReplicationControllerStatusObjectNested withNewReplicationControllerStatusObjectLike(ReplicationControllerStatus item){
            return new ReplicationControllerStatusObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PipelineConfigObjectNested withNewPipelineConfigObject(){
            return new PipelineConfigObjectNestedImpl();
    }

    public WatchEventFluent.PipelineConfigObjectNested withNewPipelineConfigObjectLike(PipelineConfig item){
            return new PipelineConfigObjectNestedImpl(item);
    }

    public A withTolerationObject(Toleration tolerationObject){
            _visitables.remove(this.object);
            if (tolerationObject!=null){ this.object= new TolerationBuilder(tolerationObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.TolerationObjectNested withNewTolerationObject(){
            return new TolerationObjectNestedImpl();
    }

    public WatchEventFluent.TolerationObjectNested withNewTolerationObjectLike(Toleration item){
            return new TolerationObjectNestedImpl(item);
    }

    public A withNewTolerationObject(String effect,String key,String operator,Long tolerationSeconds,String value){
            return (A)withTolerationObject(new Toleration(effect, key, operator, tolerationSeconds, value));
    }

    public A withCodeRepoServiceObject(CodeRepoService codeRepoServiceObject){
            _visitables.remove(this.object);
            if (codeRepoServiceObject!=null){ this.object= new CodeRepoServiceBuilder(codeRepoServiceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoServiceObjectNested withNewCodeRepoServiceObject(){
            return new CodeRepoServiceObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoServiceObjectNested withNewCodeRepoServiceObjectLike(CodeRepoService item){
            return new CodeRepoServiceObjectNestedImpl(item);
    }

    public A withPipelineTaskArgumentValidationObject(PipelineTaskArgumentValidation pipelineTaskArgumentValidationObject){
            _visitables.remove(this.object);
            if (pipelineTaskArgumentValidationObject!=null){ this.object= new PipelineTaskArgumentValidationBuilder(pipelineTaskArgumentValidationObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskArgumentValidationObjectNested withNewPipelineTaskArgumentValidationObject(){
            return new PipelineTaskArgumentValidationObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskArgumentValidationObjectNested withNewPipelineTaskArgumentValidationObjectLike(PipelineTaskArgumentValidation item){
            return new PipelineTaskArgumentValidationObjectNestedImpl(item);
    }

    public A withNewPipelineTaskArgumentValidationObject(String pattern){
            return (A)withPipelineTaskArgumentValidationObject(new PipelineTaskArgumentValidation(pattern));
    }

    public A withAttachedVolumeObject(AttachedVolume attachedVolumeObject){
            _visitables.remove(this.object);
            if (attachedVolumeObject!=null){ this.object= new AttachedVolumeBuilder(attachedVolumeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AttachedVolumeObjectNested withNewAttachedVolumeObject(){
            return new AttachedVolumeObjectNestedImpl();
    }

    public WatchEventFluent.AttachedVolumeObjectNested withNewAttachedVolumeObjectLike(AttachedVolume item){
            return new AttachedVolumeObjectNestedImpl(item);
    }

    public A withNewAttachedVolumeObject(String devicePath,String name){
            return (A)withAttachedVolumeObject(new AttachedVolume(devicePath, name));
    }

    public A withStatefulSetListObject(StatefulSetList statefulSetListObject){
            _visitables.remove(this.object);
            if (statefulSetListObject!=null){ this.object= new StatefulSetListBuilder(statefulSetListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatefulSetListObjectNested withNewStatefulSetListObject(){
            return new StatefulSetListObjectNestedImpl();
    }

    public WatchEventFluent.StatefulSetListObjectNested withNewStatefulSetListObjectLike(StatefulSetList item){
            return new StatefulSetListObjectNestedImpl(item);
    }

    public A withJenkinsStatusObject(JenkinsStatus jenkinsStatusObject){
            _visitables.remove(this.object);
            if (jenkinsStatusObject!=null){ this.object= new JenkinsStatusBuilder(jenkinsStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsStatusObjectNested withNewJenkinsStatusObject(){
            return new JenkinsStatusObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsStatusObjectNested withNewJenkinsStatusObjectLike(JenkinsStatus item){
            return new JenkinsStatusObjectNestedImpl(item);
    }

    public A withPipelineTriggerCodeChangeObject(PipelineTriggerCodeChange pipelineTriggerCodeChangeObject){
            _visitables.remove(this.object);
            if (pipelineTriggerCodeChangeObject!=null){ this.object= new PipelineTriggerCodeChangeBuilder(pipelineTriggerCodeChangeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTriggerCodeChangeObjectNested withNewPipelineTriggerCodeChangeObject(){
            return new PipelineTriggerCodeChangeObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTriggerCodeChangeObjectNested withNewPipelineTriggerCodeChangeObjectLike(PipelineTriggerCodeChange item){
            return new PipelineTriggerCodeChangeObjectNestedImpl(item);
    }

    public A withNewPipelineTriggerCodeChangeObject(Boolean enabled,String periodicCheck){
            return (A)withPipelineTriggerCodeChangeObject(new PipelineTriggerCodeChange(enabled, periodicCheck));
    }

    public A withNamedExtensionObject(NamedExtension namedExtensionObject){
            _visitables.remove(this.object);
            if (namedExtensionObject!=null){ this.object= new NamedExtensionBuilder(namedExtensionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NamedExtensionObjectNested withNewNamedExtensionObject(){
            return new NamedExtensionObjectNestedImpl();
    }

    public WatchEventFluent.NamedExtensionObjectNested withNewNamedExtensionObjectLike(NamedExtension item){
            return new NamedExtensionObjectNestedImpl(item);
    }

    public A withServiceListObject(ServiceList serviceListObject){
            _visitables.remove(this.object);
            if (serviceListObject!=null){ this.object= new ServiceListBuilder(serviceListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServiceListObjectNested withNewServiceListObject(){
            return new ServiceListObjectNestedImpl();
    }

    public WatchEventFluent.ServiceListObjectNested withNewServiceListObjectLike(ServiceList item){
            return new ServiceListObjectNestedImpl(item);
    }

    public A withIngressStatusObject(IngressStatus ingressStatusObject){
            _visitables.remove(this.object);
            if (ingressStatusObject!=null){ this.object= new IngressStatusBuilder(ingressStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.IngressStatusObjectNested withNewIngressStatusObject(){
            return new IngressStatusObjectNestedImpl();
    }

    public WatchEventFluent.IngressStatusObjectNested withNewIngressStatusObjectLike(IngressStatus item){
            return new IngressStatusObjectNestedImpl(item);
    }

    public A withInitializersObject(Initializers initializersObject){
            _visitables.remove(this.object);
            if (initializersObject!=null){ this.object= new InitializersBuilder(initializersObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.InitializersObjectNested withNewInitializersObject(){
            return new InitializersObjectNestedImpl();
    }

    public WatchEventFluent.InitializersObjectNested withNewInitializersObjectLike(Initializers item){
            return new InitializersObjectNestedImpl(item);
    }

    public A withSecretKeySelectorObject(SecretKeySelector secretKeySelectorObject){
            _visitables.remove(this.object);
            if (secretKeySelectorObject!=null){ this.object= new SecretKeySelectorBuilder(secretKeySelectorObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretKeySelectorObjectNested withNewSecretKeySelectorObject(){
            return new SecretKeySelectorObjectNestedImpl();
    }

    public WatchEventFluent.SecretKeySelectorObjectNested withNewSecretKeySelectorObjectLike(SecretKeySelector item){
            return new SecretKeySelectorObjectNestedImpl(item);
    }

    public A withNewSecretKeySelectorObject(String key,String name,Boolean optional){
            return (A)withSecretKeySelectorObject(new SecretKeySelector(key, name, optional));
    }

    public A withPodConditionObject(PodCondition podConditionObject){
            _visitables.remove(this.object);
            if (podConditionObject!=null){ this.object= new PodConditionBuilder(podConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodConditionObjectNested withNewPodConditionObject(){
            return new PodConditionObjectNestedImpl();
    }

    public WatchEventFluent.PodConditionObjectNested withNewPodConditionObjectLike(PodCondition item){
            return new PodConditionObjectNestedImpl(item);
    }

    public A withSupplementalGroupsStrategyOptionsObject(SupplementalGroupsStrategyOptions supplementalGroupsStrategyOptionsObject){
            _visitables.remove(this.object);
            if (supplementalGroupsStrategyOptionsObject!=null){ this.object= new SupplementalGroupsStrategyOptionsBuilder(supplementalGroupsStrategyOptionsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SupplementalGroupsStrategyOptionsObjectNested withNewSupplementalGroupsStrategyOptionsObject(){
            return new SupplementalGroupsStrategyOptionsObjectNestedImpl();
    }

    public WatchEventFluent.SupplementalGroupsStrategyOptionsObjectNested withNewSupplementalGroupsStrategyOptionsObjectLike(SupplementalGroupsStrategyOptions item){
            return new SupplementalGroupsStrategyOptionsObjectNestedImpl(item);
    }

    public A withContainerStateTerminatedObject(ContainerStateTerminated containerStateTerminatedObject){
            _visitables.remove(this.object);
            if (containerStateTerminatedObject!=null){ this.object= new ContainerStateTerminatedBuilder(containerStateTerminatedObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerStateTerminatedObjectNested withNewContainerStateTerminatedObject(){
            return new ContainerStateTerminatedObjectNestedImpl();
    }

    public WatchEventFluent.ContainerStateTerminatedObjectNested withNewContainerStateTerminatedObjectLike(ContainerStateTerminated item){
            return new ContainerStateTerminatedObjectNestedImpl(item);
    }

    public A withHostPortStatusObject(HostPortStatus hostPortStatusObject){
            _visitables.remove(this.object);
            if (hostPortStatusObject!=null){ this.object= new HostPortStatusBuilder(hostPortStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HostPortStatusObjectNested withNewHostPortStatusObject(){
            return new HostPortStatusObjectNestedImpl();
    }

    public WatchEventFluent.HostPortStatusObjectNested withNewHostPortStatusObjectLike(HostPortStatus item){
            return new HostPortStatusObjectNestedImpl(item);
    }

    public A withNewHostPortStatusObject(Long delay,String lastAttempt,String response,Integer statusCode,String version){
            return (A)withHostPortStatusObject(new HostPortStatus(delay, lastAttempt, response, statusCode, version));
    }

    public A withReplicaSetSpecObject(ReplicaSetSpec replicaSetSpecObject){
            _visitables.remove(this.object);
            if (replicaSetSpecObject!=null){ this.object= new ReplicaSetSpecBuilder(replicaSetSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicaSetSpecObjectNested withNewReplicaSetSpecObject(){
            return new ReplicaSetSpecObjectNestedImpl();
    }

    public WatchEventFluent.ReplicaSetSpecObjectNested withNewReplicaSetSpecObjectLike(ReplicaSetSpec item){
            return new ReplicaSetSpecObjectNestedImpl(item);
    }

    public A withPipelineSourceGitObject(PipelineSourceGit pipelineSourceGitObject){
            _visitables.remove(this.object);
            if (pipelineSourceGitObject!=null){ this.object= new PipelineSourceGitBuilder(pipelineSourceGitObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineSourceGitObjectNested withNewPipelineSourceGitObject(){
            return new PipelineSourceGitObjectNestedImpl();
    }

    public WatchEventFluent.PipelineSourceGitObjectNested withNewPipelineSourceGitObjectLike(PipelineSourceGit item){
            return new PipelineSourceGitObjectNestedImpl(item);
    }

    public A withNewPipelineSourceGitObject(String ref,String uri){
            return (A)withPipelineSourceGitObject(new PipelineSourceGit(ref, uri));
    }

    public A withISCSIVolumeSourceObject(ISCSIVolumeSource iSCSIVolumeSourceObject){
            _visitables.remove(this.object);
            if (iSCSIVolumeSourceObject!=null){ this.object= new ISCSIVolumeSourceBuilder(iSCSIVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ISCSIVolumeSourceObjectNested withNewISCSIVolumeSourceObject(){
            return new ISCSIVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.ISCSIVolumeSourceObjectNested withNewISCSIVolumeSourceObjectLike(ISCSIVolumeSource item){
            return new ISCSIVolumeSourceObjectNestedImpl(item);
    }

    public A withAzureDiskVolumeSourceObject(AzureDiskVolumeSource azureDiskVolumeSourceObject){
            _visitables.remove(this.object);
            if (azureDiskVolumeSourceObject!=null){ this.object= new AzureDiskVolumeSourceBuilder(azureDiskVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AzureDiskVolumeSourceObjectNested withNewAzureDiskVolumeSourceObject(){
            return new AzureDiskVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.AzureDiskVolumeSourceObjectNested withNewAzureDiskVolumeSourceObjectLike(AzureDiskVolumeSource item){
            return new AzureDiskVolumeSourceObjectNestedImpl(item);
    }

    public A withPipelineTaskArgumentWhenObject(PipelineTaskArgumentWhen pipelineTaskArgumentWhenObject){
            _visitables.remove(this.object);
            if (pipelineTaskArgumentWhenObject!=null){ this.object= new PipelineTaskArgumentWhenBuilder(pipelineTaskArgumentWhenObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskArgumentWhenObjectNested withNewPipelineTaskArgumentWhenObject(){
            return new PipelineTaskArgumentWhenObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskArgumentWhenObjectNested withNewPipelineTaskArgumentWhenObjectLike(PipelineTaskArgumentWhen item){
            return new PipelineTaskArgumentWhenObjectNestedImpl(item);
    }

    public A withNewPipelineTaskArgumentWhenObject(String name,Boolean value){
            return (A)withPipelineTaskArgumentWhenObject(new PipelineTaskArgumentWhen(name, value));
    }

    public A withDownwardAPIVolumeSourceObject(DownwardAPIVolumeSource downwardAPIVolumeSourceObject){
            _visitables.remove(this.object);
            if (downwardAPIVolumeSourceObject!=null){ this.object= new DownwardAPIVolumeSourceBuilder(downwardAPIVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DownwardAPIVolumeSourceObjectNested withNewDownwardAPIVolumeSourceObject(){
            return new DownwardAPIVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.DownwardAPIVolumeSourceObjectNested withNewDownwardAPIVolumeSourceObjectLike(DownwardAPIVolumeSource item){
            return new DownwardAPIVolumeSourceObjectNestedImpl(item);
    }

    public A withStorageClassListObject(StorageClassList storageClassListObject){
            _visitables.remove(this.object);
            if (storageClassListObject!=null){ this.object= new StorageClassListBuilder(storageClassListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StorageClassListObjectNested withNewStorageClassListObject(){
            return new StorageClassListObjectNestedImpl();
    }

    public WatchEventFluent.StorageClassListObjectNested withNewStorageClassListObjectLike(StorageClassList item){
            return new StorageClassListObjectNestedImpl(item);
    }

    public A withGitRepoVolumeSourceObject(GitRepoVolumeSource gitRepoVolumeSourceObject){
            _visitables.remove(this.object);
            if (gitRepoVolumeSourceObject!=null){ this.object= new GitRepoVolumeSourceBuilder(gitRepoVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.GitRepoVolumeSourceObjectNested withNewGitRepoVolumeSourceObject(){
            return new GitRepoVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.GitRepoVolumeSourceObjectNested withNewGitRepoVolumeSourceObjectLike(GitRepoVolumeSource item){
            return new GitRepoVolumeSourceObjectNestedImpl(item);
    }

    public A withNewGitRepoVolumeSourceObject(String directory,String repository,String revision){
            return (A)withGitRepoVolumeSourceObject(new GitRepoVolumeSource(directory, repository, revision));
    }

    public A withCodeRepositoryRefObject(CodeRepositoryRef codeRepositoryRefObject){
            _visitables.remove(this.object);
            if (codeRepositoryRefObject!=null){ this.object= new CodeRepositoryRefBuilder(codeRepositoryRefObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositoryRefObjectNested withNewCodeRepositoryRefObject(){
            return new CodeRepositoryRefObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositoryRefObjectNested withNewCodeRepositoryRefObjectLike(CodeRepositoryRef item){
            return new CodeRepositoryRefObjectNestedImpl(item);
    }

    public A withNewCodeRepositoryRefObject(String name,String ref){
            return (A)withCodeRepositoryRefObject(new CodeRepositoryRef(name, ref));
    }

    public A withPodTemplateSpecObject(PodTemplateSpec podTemplateSpecObject){
            _visitables.remove(this.object);
            if (podTemplateSpecObject!=null){ this.object= new PodTemplateSpecBuilder(podTemplateSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodTemplateSpecObjectNested withNewPodTemplateSpecObject(){
            return new PodTemplateSpecObjectNestedImpl();
    }

    public WatchEventFluent.PodTemplateSpecObjectNested withNewPodTemplateSpecObjectLike(PodTemplateSpec item){
            return new PodTemplateSpecObjectNestedImpl(item);
    }

    public A withJenkinsSpecObject(JenkinsSpec jenkinsSpecObject){
            _visitables.remove(this.object);
            if (jenkinsSpecObject!=null){ this.object= new JenkinsSpecBuilder(jenkinsSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsSpecObjectNested withNewJenkinsSpecObject(){
            return new JenkinsSpecObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsSpecObjectNested withNewJenkinsSpecObjectLike(JenkinsSpec item){
            return new JenkinsSpecObjectNestedImpl(item);
    }

    public A withPipelineTemplateTaskInstanceSpecObject(PipelineTemplateTaskInstanceSpec pipelineTemplateTaskInstanceSpecObject){
            _visitables.remove(this.object);
            if (pipelineTemplateTaskInstanceSpecObject!=null){ this.object= new PipelineTemplateTaskInstanceSpecBuilder(pipelineTemplateTaskInstanceSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateTaskInstanceSpecObjectNested withNewPipelineTemplateTaskInstanceSpecObject(){
            return new PipelineTemplateTaskInstanceSpecObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateTaskInstanceSpecObjectNested withNewPipelineTemplateTaskInstanceSpecObjectLike(PipelineTemplateTaskInstanceSpec item){
            return new PipelineTemplateTaskInstanceSpecObjectNestedImpl(item);
    }

    public A withContainerStateRunningObject(ContainerStateRunning containerStateRunningObject){
            _visitables.remove(this.object);
            if (containerStateRunningObject!=null){ this.object= new ContainerStateRunningBuilder(containerStateRunningObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerStateRunningObjectNested withNewContainerStateRunningObject(){
            return new ContainerStateRunningObjectNestedImpl();
    }

    public WatchEventFluent.ContainerStateRunningObjectNested withNewContainerStateRunningObjectLike(ContainerStateRunning item){
            return new ContainerStateRunningObjectNestedImpl(item);
    }

    public A withNewContainerStateRunningObject(String startedAt){
            return (A)withContainerStateRunningObject(new ContainerStateRunning(startedAt));
    }

    public A withOwnerReferenceObject(OwnerReference ownerReferenceObject){
            _visitables.remove(this.object);
            if (ownerReferenceObject!=null){ this.object= new OwnerReferenceBuilder(ownerReferenceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.OwnerReferenceObjectNested withNewOwnerReferenceObject(){
            return new OwnerReferenceObjectNestedImpl();
    }

    public WatchEventFluent.OwnerReferenceObjectNested withNewOwnerReferenceObjectLike(OwnerReference item){
            return new OwnerReferenceObjectNestedImpl(item);
    }

    public A withConfigMapVolumeSourceObject(ConfigMapVolumeSource configMapVolumeSourceObject){
            _visitables.remove(this.object);
            if (configMapVolumeSourceObject!=null){ this.object= new ConfigMapVolumeSourceBuilder(configMapVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ConfigMapVolumeSourceObjectNested withNewConfigMapVolumeSourceObject(){
            return new ConfigMapVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.ConfigMapVolumeSourceObjectNested withNewConfigMapVolumeSourceObjectLike(ConfigMapVolumeSource item){
            return new ConfigMapVolumeSourceObjectNestedImpl(item);
    }

    public A withLabelSelectorRequirementObject(LabelSelectorRequirement labelSelectorRequirementObject){
            _visitables.remove(this.object);
            if (labelSelectorRequirementObject!=null){ this.object= new LabelSelectorRequirementBuilder(labelSelectorRequirementObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LabelSelectorRequirementObjectNested withNewLabelSelectorRequirementObject(){
            return new LabelSelectorRequirementObjectNestedImpl();
    }

    public WatchEventFluent.LabelSelectorRequirementObjectNested withNewLabelSelectorRequirementObjectLike(LabelSelectorRequirement item){
            return new LabelSelectorRequirementObjectNestedImpl(item);
    }

    public A withJenkinsInstanceObject(JenkinsInstance jenkinsInstanceObject){
            _visitables.remove(this.object);
            if (jenkinsInstanceObject!=null){ this.object= new JenkinsInstanceBuilder(jenkinsInstanceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsInstanceObjectNested withNewJenkinsInstanceObject(){
            return new JenkinsInstanceObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsInstanceObjectNested withNewJenkinsInstanceObjectLike(JenkinsInstance item){
            return new JenkinsInstanceObjectNestedImpl(item);
    }

    public A withNewJenkinsInstanceObject(String name){
            return (A)withJenkinsInstanceObject(new JenkinsInstance(name));
    }

    public A withResourceAttributesObject(ResourceAttributes resourceAttributesObject){
            _visitables.remove(this.object);
            if (resourceAttributesObject!=null){ this.object= new ResourceAttributesBuilder(resourceAttributesObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceAttributesObjectNested withNewResourceAttributesObject(){
            return new ResourceAttributesObjectNestedImpl();
    }

    public WatchEventFluent.ResourceAttributesObjectNested withNewResourceAttributesObjectLike(ResourceAttributes item){
            return new ResourceAttributesObjectNestedImpl(item);
    }

    public A withFlockerVolumeSourceObject(FlockerVolumeSource flockerVolumeSourceObject){
            _visitables.remove(this.object);
            if (flockerVolumeSourceObject!=null){ this.object= new FlockerVolumeSourceBuilder(flockerVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.FlockerVolumeSourceObjectNested withNewFlockerVolumeSourceObject(){
            return new FlockerVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.FlockerVolumeSourceObjectNested withNewFlockerVolumeSourceObjectLike(FlockerVolumeSource item){
            return new FlockerVolumeSourceObjectNestedImpl(item);
    }

    public A withNewFlockerVolumeSourceObject(String datasetName,String datasetUUID){
            return (A)withFlockerVolumeSourceObject(new FlockerVolumeSource(datasetName, datasetUUID));
    }

    public A withPodAntiAffinityObject(PodAntiAffinity podAntiAffinityObject){
            _visitables.remove(this.object);
            if (podAntiAffinityObject!=null){ this.object= new PodAntiAffinityBuilder(podAntiAffinityObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodAntiAffinityObjectNested withNewPodAntiAffinityObject(){
            return new PodAntiAffinityObjectNestedImpl();
    }

    public WatchEventFluent.PodAntiAffinityObjectNested withNewPodAntiAffinityObjectLike(PodAntiAffinity item){
            return new PodAntiAffinityObjectNestedImpl(item);
    }

    public A withNamedContextObject(NamedContext namedContextObject){
            _visitables.remove(this.object);
            if (namedContextObject!=null){ this.object= new NamedContextBuilder(namedContextObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NamedContextObjectNested withNewNamedContextObject(){
            return new NamedContextObjectNestedImpl();
    }

    public WatchEventFluent.NamedContextObjectNested withNewNamedContextObjectLike(NamedContext item){
            return new NamedContextObjectNestedImpl(item);
    }

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

    public WatchEventFluent.EnvVarObjectNested withNewEnvVarObject(){
            return new EnvVarObjectNestedImpl();
    }

    public WatchEventFluent.EnvVarObjectNested withNewEnvVarObjectLike(EnvVar item){
            return new EnvVarObjectNestedImpl(item);
    }

    public A withScaleIOVolumeSourceObject(ScaleIOVolumeSource scaleIOVolumeSourceObject){
            _visitables.remove(this.object);
            if (scaleIOVolumeSourceObject!=null){ this.object= new ScaleIOVolumeSourceBuilder(scaleIOVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ScaleIOVolumeSourceObjectNested withNewScaleIOVolumeSourceObject(){
            return new ScaleIOVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.ScaleIOVolumeSourceObjectNested withNewScaleIOVolumeSourceObjectLike(ScaleIOVolumeSource item){
            return new ScaleIOVolumeSourceObjectNestedImpl(item);
    }

    public A withMultiBranchPipelineObject(MultiBranchPipeline multiBranchPipelineObject){
            _visitables.remove(this.object);
            if (multiBranchPipelineObject!=null){ this.object= new MultiBranchPipelineBuilder(multiBranchPipelineObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.MultiBranchPipelineObjectNested withNewMultiBranchPipelineObject(){
            return new MultiBranchPipelineObjectNestedImpl();
    }

    public WatchEventFluent.MultiBranchPipelineObjectNested withNewMultiBranchPipelineObjectLike(MultiBranchPipeline item){
            return new MultiBranchPipelineObjectNestedImpl(item);
    }

    public A withHandlerObject(Handler handlerObject){
            _visitables.remove(this.object);
            if (handlerObject!=null){ this.object= new HandlerBuilder(handlerObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HandlerObjectNested withNewHandlerObject(){
            return new HandlerObjectNestedImpl();
    }

    public WatchEventFluent.HandlerObjectNested withNewHandlerObjectLike(Handler item){
            return new HandlerObjectNestedImpl(item);
    }

    public A withServiceStatusObject(ServiceStatus serviceStatusObject){
            _visitables.remove(this.object);
            if (serviceStatusObject!=null){ this.object= new ServiceStatusBuilder(serviceStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServiceStatusObjectNested withNewServiceStatusObject(){
            return new ServiceStatusObjectNestedImpl();
    }

    public WatchEventFluent.ServiceStatusObjectNested withNewServiceStatusObjectLike(ServiceStatus item){
            return new ServiceStatusObjectNestedImpl(item);
    }

    public A withIDRangeObject(IDRange iDRangeObject){
            _visitables.remove(this.object);
            if (iDRangeObject!=null){ this.object= new IDRangeBuilder(iDRangeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.IDRangeObjectNested withNewIDRangeObject(){
            return new IDRangeObjectNestedImpl();
    }

    public WatchEventFluent.IDRangeObjectNested withNewIDRangeObjectLike(IDRange item){
            return new IDRangeObjectNestedImpl(item);
    }

    public A withNewIDRangeObject(Long max,Long min){
            return (A)withIDRangeObject(new IDRange(max, min));
    }

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

    public WatchEventFluent.HorizontalPodAutoscalerListObjectNested withNewHorizontalPodAutoscalerListObject(){
            return new HorizontalPodAutoscalerListObjectNestedImpl();
    }

    public WatchEventFluent.HorizontalPodAutoscalerListObjectNested withNewHorizontalPodAutoscalerListObjectLike(HorizontalPodAutoscalerList item){
            return new HorizontalPodAutoscalerListObjectNestedImpl(item);
    }

    public A withReplicaSetConditionObject(ReplicaSetCondition replicaSetConditionObject){
            _visitables.remove(this.object);
            if (replicaSetConditionObject!=null){ this.object= new ReplicaSetConditionBuilder(replicaSetConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicaSetConditionObjectNested withNewReplicaSetConditionObject(){
            return new ReplicaSetConditionObjectNestedImpl();
    }

    public WatchEventFluent.ReplicaSetConditionObjectNested withNewReplicaSetConditionObjectLike(ReplicaSetCondition item){
            return new ReplicaSetConditionObjectNestedImpl(item);
    }

    public A withNewReplicaSetConditionObject(String lastTransitionTime,String message,String reason,String status,String type){
            return (A)withReplicaSetConditionObject(new ReplicaSetCondition(lastTransitionTime, message, reason, status, type));
    }

    public A withPipelineSourceObject(PipelineSource pipelineSourceObject){
            _visitables.remove(this.object);
            if (pipelineSourceObject!=null){ this.object= new PipelineSourceBuilder(pipelineSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineSourceObjectNested withNewPipelineSourceObject(){
            return new PipelineSourceObjectNestedImpl();
    }

    public WatchEventFluent.PipelineSourceObjectNested withNewPipelineSourceObjectLike(PipelineSource item){
            return new PipelineSourceObjectNestedImpl(item);
    }

    public A withPodStatusObject(PodStatus podStatusObject){
            _visitables.remove(this.object);
            if (podStatusObject!=null){ this.object= new PodStatusBuilder(podStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodStatusObjectNested withNewPodStatusObject(){
            return new PodStatusObjectNestedImpl();
    }

    public WatchEventFluent.PodStatusObjectNested withNewPodStatusObjectLike(PodStatus item){
            return new PodStatusObjectNestedImpl(item);
    }

    public A withAuthProviderConfigObject(AuthProviderConfig authProviderConfigObject){
            _visitables.remove(this.object);
            if (authProviderConfigObject!=null){ this.object= new AuthProviderConfigBuilder(authProviderConfigObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.AuthProviderConfigObjectNested withNewAuthProviderConfigObject(){
            return new AuthProviderConfigObjectNestedImpl();
    }

    public WatchEventFluent.AuthProviderConfigObjectNested withNewAuthProviderConfigObjectLike(AuthProviderConfig item){
            return new AuthProviderConfigObjectNestedImpl(item);
    }

    public A withJenkinsPluginObject(JenkinsPlugin jenkinsPluginObject){
            _visitables.remove(this.object);
            if (jenkinsPluginObject!=null){ this.object= new JenkinsPluginBuilder(jenkinsPluginObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsPluginObjectNested withNewJenkinsPluginObject(){
            return new JenkinsPluginObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsPluginObjectNested withNewJenkinsPluginObjectLike(JenkinsPlugin item){
            return new JenkinsPluginObjectNestedImpl(item);
    }

    public A withNewJenkinsPluginObject(String name,String version){
            return (A)withJenkinsPluginObject(new JenkinsPlugin(name, version));
    }

    public A withGCEPersistentDiskVolumeSourceObject(GCEPersistentDiskVolumeSource gCEPersistentDiskVolumeSourceObject){
            _visitables.remove(this.object);
            if (gCEPersistentDiskVolumeSourceObject!=null){ this.object= new GCEPersistentDiskVolumeSourceBuilder(gCEPersistentDiskVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.GCEPersistentDiskVolumeSourceObjectNested withNewGCEPersistentDiskVolumeSourceObject(){
            return new GCEPersistentDiskVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.GCEPersistentDiskVolumeSourceObjectNested withNewGCEPersistentDiskVolumeSourceObjectLike(GCEPersistentDiskVolumeSource item){
            return new GCEPersistentDiskVolumeSourceObjectNestedImpl(item);
    }

    public A withNewGCEPersistentDiskVolumeSourceObject(String fsType,Integer partition,String pdName,Boolean readOnly){
            return (A)withGCEPersistentDiskVolumeSourceObject(new GCEPersistentDiskVolumeSource(fsType, partition, pdName, readOnly));
    }

    public A withEmptyDirVolumeSourceObject(EmptyDirVolumeSource emptyDirVolumeSourceObject){
            _visitables.remove(this.object);
            if (emptyDirVolumeSourceObject!=null){ this.object= new EmptyDirVolumeSourceBuilder(emptyDirVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EmptyDirVolumeSourceObjectNested withNewEmptyDirVolumeSourceObject(){
            return new EmptyDirVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.EmptyDirVolumeSourceObjectNested withNewEmptyDirVolumeSourceObjectLike(EmptyDirVolumeSource item){
            return new EmptyDirVolumeSourceObjectNestedImpl(item);
    }

    public A withCodeRepoBindingObject(CodeRepoBinding codeRepoBindingObject){
            _visitables.remove(this.object);
            if (codeRepoBindingObject!=null){ this.object= new CodeRepoBindingBuilder(codeRepoBindingObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoBindingObjectNested withNewCodeRepoBindingObject(){
            return new CodeRepoBindingObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoBindingObjectNested withNewCodeRepoBindingObjectLike(CodeRepoBinding item){
            return new CodeRepoBindingObjectNestedImpl(item);
    }

    public A withPipelineTemplateTaskObject(PipelineTemplateTask pipelineTemplateTaskObject){
            _visitables.remove(this.object);
            if (pipelineTemplateTaskObject!=null){ this.object= new PipelineTemplateTaskBuilder(pipelineTemplateTaskObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateTaskObjectNested withNewPipelineTemplateTaskObject(){
            return new PipelineTemplateTaskObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateTaskObjectNested withNewPipelineTemplateTaskObjectLike(PipelineTemplateTask item){
            return new PipelineTemplateTaskObjectNestedImpl(item);
    }

    public A withScaleObject(Scale scaleObject){
            _visitables.remove(this.object);
            if (scaleObject!=null){ this.object= new ScaleBuilder(scaleObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ScaleObjectNested withNewScaleObject(){
            return new ScaleObjectNestedImpl();
    }

    public WatchEventFluent.ScaleObjectNested withNewScaleObjectLike(Scale item){
            return new ScaleObjectNestedImpl(item);
    }

    public A withPipelineTaskTemplateObject(PipelineTaskTemplate pipelineTaskTemplateObject){
            _visitables.remove(this.object);
            if (pipelineTaskTemplateObject!=null){ this.object= new PipelineTaskTemplateBuilder(pipelineTaskTemplateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskTemplateObjectNested withNewPipelineTaskTemplateObject(){
            return new PipelineTaskTemplateObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskTemplateObjectNested withNewPipelineTaskTemplateObjectLike(PipelineTaskTemplate item){
            return new PipelineTaskTemplateObjectNestedImpl(item);
    }

    public A withPodSpecObject(PodSpec podSpecObject){
            _visitables.remove(this.object);
            if (podSpecObject!=null){ this.object= new PodSpecBuilder(podSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodSpecObjectNested withNewPodSpecObject(){
            return new PodSpecObjectNestedImpl();
    }

    public WatchEventFluent.PodSpecObjectNested withNewPodSpecObjectLike(PodSpec item){
            return new PodSpecObjectNestedImpl(item);
    }

    public A withNodeSpecObject(NodeSpec nodeSpecObject){
            _visitables.remove(this.object);
            if (nodeSpecObject!=null){ this.object= new NodeSpecBuilder(nodeSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeSpecObjectNested withNewNodeSpecObject(){
            return new NodeSpecObjectNestedImpl();
    }

    public WatchEventFluent.NodeSpecObjectNested withNewNodeSpecObjectLike(NodeSpec item){
            return new NodeSpecObjectNestedImpl(item);
    }

    public A withPipelineConfigSpecObject(PipelineConfigSpec pipelineConfigSpecObject){
            _visitables.remove(this.object);
            if (pipelineConfigSpecObject!=null){ this.object= new PipelineConfigSpecBuilder(pipelineConfigSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineConfigSpecObjectNested withNewPipelineConfigSpecObject(){
            return new PipelineConfigSpecObjectNestedImpl();
    }

    public WatchEventFluent.PipelineConfigSpecObjectNested withNewPipelineConfigSpecObjectLike(PipelineConfigSpec item){
            return new PipelineConfigSpecObjectNestedImpl(item);
    }

    public A withComponentConditionObject(ComponentCondition componentConditionObject){
            _visitables.remove(this.object);
            if (componentConditionObject!=null){ this.object= new ComponentConditionBuilder(componentConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ComponentConditionObjectNested withNewComponentConditionObject(){
            return new ComponentConditionObjectNestedImpl();
    }

    public WatchEventFluent.ComponentConditionObjectNested withNewComponentConditionObjectLike(ComponentCondition item){
            return new ComponentConditionObjectNestedImpl(item);
    }

    public A withNewComponentConditionObject(String error,String message,String status,String type){
            return (A)withComponentConditionObject(new ComponentCondition(error, message, status, type));
    }

    public A withPodObject(Pod podObject){
            _visitables.remove(this.object);
            if (podObject!=null){ this.object= new PodBuilder(podObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodObjectNested withNewPodObject(){
            return new PodObjectNestedImpl();
    }

    public WatchEventFluent.PodObjectNested withNewPodObjectLike(Pod item){
            return new PodObjectNestedImpl(item);
    }

    public A withCephFSVolumeSourceObject(CephFSVolumeSource cephFSVolumeSourceObject){
            _visitables.remove(this.object);
            if (cephFSVolumeSourceObject!=null){ this.object= new CephFSVolumeSourceBuilder(cephFSVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CephFSVolumeSourceObjectNested withNewCephFSVolumeSourceObject(){
            return new CephFSVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.CephFSVolumeSourceObjectNested withNewCephFSVolumeSourceObjectLike(CephFSVolumeSource item){
            return new CephFSVolumeSourceObjectNestedImpl(item);
    }

    public A withCodeRepositoryOwnerSyncObject(CodeRepositoryOwnerSync codeRepositoryOwnerSyncObject){
            _visitables.remove(this.object);
            if (codeRepositoryOwnerSyncObject!=null){ this.object= new CodeRepositoryOwnerSyncBuilder(codeRepositoryOwnerSyncObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositoryOwnerSyncObjectNested withNewCodeRepositoryOwnerSyncObject(){
            return new CodeRepositoryOwnerSyncObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositoryOwnerSyncObjectNested withNewCodeRepositoryOwnerSyncObjectLike(CodeRepositoryOwnerSync item){
            return new CodeRepositoryOwnerSyncObjectNestedImpl(item);
    }

    public A withReplicationControllerConditionObject(ReplicationControllerCondition replicationControllerConditionObject){
            _visitables.remove(this.object);
            if (replicationControllerConditionObject!=null){ this.object= new ReplicationControllerConditionBuilder(replicationControllerConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicationControllerConditionObjectNested withNewReplicationControllerConditionObject(){
            return new ReplicationControllerConditionObjectNestedImpl();
    }

    public WatchEventFluent.ReplicationControllerConditionObjectNested withNewReplicationControllerConditionObjectLike(ReplicationControllerCondition item){
            return new ReplicationControllerConditionObjectNestedImpl(item);
    }

    public A withNewReplicationControllerConditionObject(String lastTransitionTime,String message,String reason,String status,String type){
            return (A)withReplicationControllerConditionObject(new ReplicationControllerCondition(lastTransitionTime, message, reason, status, type));
    }

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

    public WatchEventFluent.HorizontalPodAutoscalerObjectNested withNewHorizontalPodAutoscalerObject(){
            return new HorizontalPodAutoscalerObjectNestedImpl();
    }

    public WatchEventFluent.HorizontalPodAutoscalerObjectNested withNewHorizontalPodAutoscalerObjectLike(HorizontalPodAutoscaler item){
            return new HorizontalPodAutoscalerObjectNestedImpl(item);
    }

    public A withConfigMapProjectionObject(ConfigMapProjection configMapProjectionObject){
            _visitables.remove(this.object);
            if (configMapProjectionObject!=null){ this.object= new ConfigMapProjectionBuilder(configMapProjectionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ConfigMapProjectionObjectNested withNewConfigMapProjectionObject(){
            return new ConfigMapProjectionObjectNestedImpl();
    }

    public WatchEventFluent.ConfigMapProjectionObjectNested withNewConfigMapProjectionObjectLike(ConfigMapProjection item){
            return new ConfigMapProjectionObjectNestedImpl(item);
    }

    public A withCrossVersionObjectReferenceObject(CrossVersionObjectReference crossVersionObjectReferenceObject){
            _visitables.remove(this.object);
            if (crossVersionObjectReferenceObject!=null){ this.object= new CrossVersionObjectReferenceBuilder(crossVersionObjectReferenceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CrossVersionObjectReferenceObjectNested withNewCrossVersionObjectReferenceObject(){
            return new CrossVersionObjectReferenceObjectNestedImpl();
    }

    public WatchEventFluent.CrossVersionObjectReferenceObjectNested withNewCrossVersionObjectReferenceObjectLike(CrossVersionObjectReference item){
            return new CrossVersionObjectReferenceObjectNestedImpl(item);
    }

    public A withNewCrossVersionObjectReferenceObject(String apiVersion,String kind,String name){
            return (A)withCrossVersionObjectReferenceObject(new CrossVersionObjectReference(apiVersion, kind, name));
    }

    public A withClusterObject(Cluster clusterObject){
            _visitables.remove(this.object);
            if (clusterObject!=null){ this.object= new ClusterBuilder(clusterObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ClusterObjectNested withNewClusterObject(){
            return new ClusterObjectNestedImpl();
    }

    public WatchEventFluent.ClusterObjectNested withNewClusterObjectLike(Cluster item){
            return new ClusterObjectNestedImpl(item);
    }

    public A withPersistentVolumeClaimStatusObject(PersistentVolumeClaimStatus persistentVolumeClaimStatusObject){
            _visitables.remove(this.object);
            if (persistentVolumeClaimStatusObject!=null){ this.object= new PersistentVolumeClaimStatusBuilder(persistentVolumeClaimStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PersistentVolumeClaimStatusObjectNested withNewPersistentVolumeClaimStatusObject(){
            return new PersistentVolumeClaimStatusObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeClaimStatusObjectNested withNewPersistentVolumeClaimStatusObjectLike(PersistentVolumeClaimStatus item){
            return new PersistentVolumeClaimStatusObjectNestedImpl(item);
    }

    public A withNetworkPolicyIngressRuleObject(NetworkPolicyIngressRule networkPolicyIngressRuleObject){
            _visitables.remove(this.object);
            if (networkPolicyIngressRuleObject!=null){ this.object= new NetworkPolicyIngressRuleBuilder(networkPolicyIngressRuleObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NetworkPolicyIngressRuleObjectNested withNewNetworkPolicyIngressRuleObject(){
            return new NetworkPolicyIngressRuleObjectNestedImpl();
    }

    public WatchEventFluent.NetworkPolicyIngressRuleObjectNested withNewNetworkPolicyIngressRuleObjectLike(NetworkPolicyIngressRule item){
            return new NetworkPolicyIngressRuleObjectNestedImpl(item);
    }

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

    public WatchEventFluent.LimitRangeListObjectNested withNewLimitRangeListObject(){
            return new LimitRangeListObjectNestedImpl();
    }

    public WatchEventFluent.LimitRangeListObjectNested withNewLimitRangeListObjectLike(LimitRangeList item){
            return new LimitRangeListObjectNestedImpl(item);
    }

    public A withEndpointAddressObject(EndpointAddress endpointAddressObject){
            _visitables.remove(this.object);
            if (endpointAddressObject!=null){ this.object= new EndpointAddressBuilder(endpointAddressObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EndpointAddressObjectNested withNewEndpointAddressObject(){
            return new EndpointAddressObjectNestedImpl();
    }

    public WatchEventFluent.EndpointAddressObjectNested withNewEndpointAddressObjectLike(EndpointAddress item){
            return new EndpointAddressObjectNestedImpl(item);
    }

    public A withProbeObject(Probe probeObject){
            _visitables.remove(this.object);
            if (probeObject!=null){ this.object= new ProbeBuilder(probeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProbeObjectNested withNewProbeObject(){
            return new ProbeObjectNestedImpl();
    }

    public WatchEventFluent.ProbeObjectNested withNewProbeObjectLike(Probe item){
            return new ProbeObjectNestedImpl(item);
    }

    public A withConfigMapKeySelectorObject(ConfigMapKeySelector configMapKeySelectorObject){
            _visitables.remove(this.object);
            if (configMapKeySelectorObject!=null){ this.object= new ConfigMapKeySelectorBuilder(configMapKeySelectorObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ConfigMapKeySelectorObjectNested withNewConfigMapKeySelectorObject(){
            return new ConfigMapKeySelectorObjectNestedImpl();
    }

    public WatchEventFluent.ConfigMapKeySelectorObjectNested withNewConfigMapKeySelectorObjectLike(ConfigMapKeySelector item){
            return new ConfigMapKeySelectorObjectNestedImpl(item);
    }

    public A withNewConfigMapKeySelectorObject(String key,String name,Boolean optional){
            return (A)withConfigMapKeySelectorObject(new ConfigMapKeySelector(key, name, optional));
    }

    public A withPipelineTemplateArgumentGroupObject(PipelineTemplateArgumentGroup pipelineTemplateArgumentGroupObject){
            _visitables.remove(this.object);
            if (pipelineTemplateArgumentGroupObject!=null){ this.object= new PipelineTemplateArgumentGroupBuilder(pipelineTemplateArgumentGroupObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateArgumentGroupObjectNested withNewPipelineTemplateArgumentGroupObject(){
            return new PipelineTemplateArgumentGroupObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateArgumentGroupObjectNested withNewPipelineTemplateArgumentGroupObjectLike(PipelineTemplateArgumentGroup item){
            return new PipelineTemplateArgumentGroupObjectNestedImpl(item);
    }

    public A withPipelineTaskTemplateSpecObject(PipelineTaskTemplateSpec pipelineTaskTemplateSpecObject){
            _visitables.remove(this.object);
            if (pipelineTaskTemplateSpecObject!=null){ this.object= new PipelineTaskTemplateSpecBuilder(pipelineTaskTemplateSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskTemplateSpecObjectNested withNewPipelineTaskTemplateSpecObject(){
            return new PipelineTaskTemplateSpecObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskTemplateSpecObjectNested withNewPipelineTaskTemplateSpecObjectLike(PipelineTaskTemplateSpec item){
            return new PipelineTaskTemplateSpecObjectNestedImpl(item);
    }

    public A withCodeRepoServiceListObject(CodeRepoServiceList codeRepoServiceListObject){
            _visitables.remove(this.object);
            if (codeRepoServiceListObject!=null){ this.object= new CodeRepoServiceListBuilder(codeRepoServiceListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepoServiceListObjectNested withNewCodeRepoServiceListObject(){
            return new CodeRepoServiceListObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepoServiceListObjectNested withNewCodeRepoServiceListObjectLike(CodeRepoServiceList item){
            return new CodeRepoServiceListObjectNestedImpl(item);
    }

    public A withPodAffinityTermObject(PodAffinityTerm podAffinityTermObject){
            _visitables.remove(this.object);
            if (podAffinityTermObject!=null){ this.object= new PodAffinityTermBuilder(podAffinityTermObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodAffinityTermObjectNested withNewPodAffinityTermObject(){
            return new PodAffinityTermObjectNestedImpl();
    }

    public WatchEventFluent.PodAffinityTermObjectNested withNewPodAffinityTermObjectLike(PodAffinityTerm item){
            return new PodAffinityTermObjectNestedImpl(item);
    }

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

    public WatchEventFluent.JobListObjectNested withNewJobListObject(){
            return new JobListObjectNestedImpl();
    }

    public WatchEventFluent.JobListObjectNested withNewJobListObjectLike(JobList item){
            return new JobListObjectNestedImpl(item);
    }

    public A withGlusterfsVolumeSourceObject(GlusterfsVolumeSource glusterfsVolumeSourceObject){
            _visitables.remove(this.object);
            if (glusterfsVolumeSourceObject!=null){ this.object= new GlusterfsVolumeSourceBuilder(glusterfsVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.GlusterfsVolumeSourceObjectNested withNewGlusterfsVolumeSourceObject(){
            return new GlusterfsVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.GlusterfsVolumeSourceObjectNested withNewGlusterfsVolumeSourceObjectLike(GlusterfsVolumeSource item){
            return new GlusterfsVolumeSourceObjectNestedImpl(item);
    }

    public A withNewGlusterfsVolumeSourceObject(String endpoints,String path,Boolean readOnly){
            return (A)withGlusterfsVolumeSourceObject(new GlusterfsVolumeSource(endpoints, path, readOnly));
    }

    public A withThirdPartyResourceObject(ThirdPartyResource thirdPartyResourceObject){
            _visitables.remove(this.object);
            if (thirdPartyResourceObject!=null){ this.object= new ThirdPartyResourceBuilder(thirdPartyResourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ThirdPartyResourceObjectNested withNewThirdPartyResourceObject(){
            return new ThirdPartyResourceObjectNestedImpl();
    }

    public WatchEventFluent.ThirdPartyResourceObjectNested withNewThirdPartyResourceObjectLike(ThirdPartyResource item){
            return new ThirdPartyResourceObjectNestedImpl(item);
    }

    public A withPortworxVolumeSourceObject(PortworxVolumeSource portworxVolumeSourceObject){
            _visitables.remove(this.object);
            if (portworxVolumeSourceObject!=null){ this.object= new PortworxVolumeSourceBuilder(portworxVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PortworxVolumeSourceObjectNested withNewPortworxVolumeSourceObject(){
            return new PortworxVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.PortworxVolumeSourceObjectNested withNewPortworxVolumeSourceObjectLike(PortworxVolumeSource item){
            return new PortworxVolumeSourceObjectNestedImpl(item);
    }

    public A withNewPortworxVolumeSourceObject(String fsType,Boolean readOnly,String volumeID){
            return (A)withPortworxVolumeSourceObject(new PortworxVolumeSource(fsType, readOnly, volumeID));
    }

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

    public WatchEventFluent.CronJobListObjectNested withNewCronJobListObject(){
            return new CronJobListObjectNestedImpl();
    }

    public WatchEventFluent.CronJobListObjectNested withNewCronJobListObjectLike(CronJobList item){
            return new CronJobListObjectNestedImpl(item);
    }

    public A withRBDVolumeSourceObject(RBDVolumeSource rBDVolumeSourceObject){
            _visitables.remove(this.object);
            if (rBDVolumeSourceObject!=null){ this.object= new RBDVolumeSourceBuilder(rBDVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RBDVolumeSourceObjectNested withNewRBDVolumeSourceObject(){
            return new RBDVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.RBDVolumeSourceObjectNested withNewRBDVolumeSourceObjectLike(RBDVolumeSource item){
            return new RBDVolumeSourceObjectNestedImpl(item);
    }

    public A withPipelineHookObject(PipelineHook pipelineHookObject){
            _visitables.remove(this.object);
            if (pipelineHookObject!=null){ this.object= new PipelineHookBuilder(pipelineHookObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineHookObjectNested withNewPipelineHookObject(){
            return new PipelineHookObjectNestedImpl();
    }

    public WatchEventFluent.PipelineHookObjectNested withNewPipelineHookObjectLike(PipelineHook item){
            return new PipelineHookObjectNestedImpl(item);
    }

    public A withCronJobStatusObject(CronJobStatus cronJobStatusObject){
            _visitables.remove(this.object);
            if (cronJobStatusObject!=null){ this.object= new CronJobStatusBuilder(cronJobStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CronJobStatusObjectNested withNewCronJobStatusObject(){
            return new CronJobStatusObjectNestedImpl();
    }

    public WatchEventFluent.CronJobStatusObjectNested withNewCronJobStatusObjectLike(CronJobStatus item){
            return new CronJobStatusObjectNestedImpl(item);
    }

    public A withStorageOSVolumeSourceObject(StorageOSVolumeSource storageOSVolumeSourceObject){
            _visitables.remove(this.object);
            if (storageOSVolumeSourceObject!=null){ this.object= new StorageOSVolumeSourceBuilder(storageOSVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StorageOSVolumeSourceObjectNested withNewStorageOSVolumeSourceObject(){
            return new StorageOSVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.StorageOSVolumeSourceObjectNested withNewStorageOSVolumeSourceObjectLike(StorageOSVolumeSource item){
            return new StorageOSVolumeSourceObjectNestedImpl(item);
    }

    public A withServiceAccountListObject(ServiceAccountList serviceAccountListObject){
            _visitables.remove(this.object);
            if (serviceAccountListObject!=null){ this.object= new ServiceAccountListBuilder(serviceAccountListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServiceAccountListObjectNested withNewServiceAccountListObject(){
            return new ServiceAccountListObjectNestedImpl();
    }

    public WatchEventFluent.ServiceAccountListObjectNested withNewServiceAccountListObjectLike(ServiceAccountList item){
            return new ServiceAccountListObjectNestedImpl(item);
    }

    public A withComponentStatusObject(ComponentStatus componentStatusObject){
            _visitables.remove(this.object);
            if (componentStatusObject!=null){ this.object= new ComponentStatusBuilder(componentStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ComponentStatusObjectNested withNewComponentStatusObject(){
            return new ComponentStatusObjectNestedImpl();
    }

    public WatchEventFluent.ComponentStatusObjectNested withNewComponentStatusObjectLike(ComponentStatus item){
            return new ComponentStatusObjectNestedImpl(item);
    }

    public A withThirdPartyResourceListObject(ThirdPartyResourceList thirdPartyResourceListObject){
            _visitables.remove(this.object);
            if (thirdPartyResourceListObject!=null){ this.object= new ThirdPartyResourceListBuilder(thirdPartyResourceListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ThirdPartyResourceListObjectNested withNewThirdPartyResourceListObject(){
            return new ThirdPartyResourceListObjectNestedImpl();
    }

    public WatchEventFluent.ThirdPartyResourceListObjectNested withNewThirdPartyResourceListObjectLike(ThirdPartyResourceList item){
            return new ThirdPartyResourceListObjectNestedImpl(item);
    }

    public A withProjectedVolumeSourceObject(ProjectedVolumeSource projectedVolumeSourceObject){
            _visitables.remove(this.object);
            if (projectedVolumeSourceObject!=null){ this.object= new ProjectedVolumeSourceBuilder(projectedVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectedVolumeSourceObjectNested withNewProjectedVolumeSourceObject(){
            return new ProjectedVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.ProjectedVolumeSourceObjectNested withNewProjectedVolumeSourceObjectLike(ProjectedVolumeSource item){
            return new ProjectedVolumeSourceObjectNestedImpl(item);
    }

    public A withHostPortObject(HostPort hostPortObject){
            _visitables.remove(this.object);
            if (hostPortObject!=null){ this.object= new HostPortBuilder(hostPortObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HostPortObjectNested withNewHostPortObject(){
            return new HostPortObjectNestedImpl();
    }

    public WatchEventFluent.HostPortObjectNested withNewHostPortObjectLike(HostPort item){
            return new HostPortObjectNestedImpl(item);
    }

    public A withNewHostPortObject(String host){
            return (A)withHostPortObject(new HostPort(host));
    }

    public A withIngressBackendObject(IngressBackend ingressBackendObject){
            _visitables.remove(this.object);
            if (ingressBackendObject!=null){ this.object= new IngressBackendBuilder(ingressBackendObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.IngressBackendObjectNested withNewIngressBackendObject(){
            return new IngressBackendObjectNestedImpl();
    }

    public WatchEventFluent.IngressBackendObjectNested withNewIngressBackendObjectLike(IngressBackend item){
            return new IngressBackendObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PersistentVolumeClaimObjectNested withNewPersistentVolumeClaimObject(){
            return new PersistentVolumeClaimObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeClaimObjectNested withNewPersistentVolumeClaimObjectLike(PersistentVolumeClaim item){
            return new PersistentVolumeClaimObjectNestedImpl(item);
    }

    public A withPipelineDependencyObject(PipelineDependency pipelineDependencyObject){
            _visitables.remove(this.object);
            if (pipelineDependencyObject!=null){ this.object= new PipelineDependencyBuilder(pipelineDependencyObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineDependencyObjectNested withNewPipelineDependencyObject(){
            return new PipelineDependencyObjectNestedImpl();
    }

    public WatchEventFluent.PipelineDependencyObjectNested withNewPipelineDependencyObjectLike(PipelineDependency item){
            return new PipelineDependencyObjectNestedImpl(item);
    }

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

    public WatchEventFluent.NetworkPolicyListObjectNested withNewNetworkPolicyListObject(){
            return new NetworkPolicyListObjectNestedImpl();
    }

    public WatchEventFluent.NetworkPolicyListObjectNested withNewNetworkPolicyListObjectLike(NetworkPolicyList item){
            return new NetworkPolicyListObjectNestedImpl(item);
    }

    public A withResourceQuotaListObject(ResourceQuotaList resourceQuotaListObject){
            _visitables.remove(this.object);
            if (resourceQuotaListObject!=null){ this.object= new ResourceQuotaListBuilder(resourceQuotaListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceQuotaListObjectNested withNewResourceQuotaListObject(){
            return new ResourceQuotaListObjectNestedImpl();
    }

    public WatchEventFluent.ResourceQuotaListObjectNested withNewResourceQuotaListObjectLike(ResourceQuotaList item){
            return new ResourceQuotaListObjectNestedImpl(item);
    }

    public A withResourceRequirementsObject(ResourceRequirements resourceRequirementsObject){
            _visitables.remove(this.object);
            if (resourceRequirementsObject!=null){ this.object= new ResourceRequirementsBuilder(resourceRequirementsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceRequirementsObjectNested withNewResourceRequirementsObject(){
            return new ResourceRequirementsObjectNestedImpl();
    }

    public WatchEventFluent.ResourceRequirementsObjectNested withNewResourceRequirementsObjectLike(ResourceRequirements item){
            return new ResourceRequirementsObjectNestedImpl(item);
    }

    public A withSecretObject(Secret secretObject){
            _visitables.remove(this.object);
            if (secretObject!=null){ this.object= new SecretBuilder(secretObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretObjectNested withNewSecretObject(){
            return new SecretObjectNestedImpl();
    }

    public WatchEventFluent.SecretObjectNested withNewSecretObjectLike(Secret item){
            return new SecretObjectNestedImpl(item);
    }

    public A withJenkinsBindingSpecObject(JenkinsBindingSpec jenkinsBindingSpecObject){
            _visitables.remove(this.object);
            if (jenkinsBindingSpecObject!=null){ this.object= new JenkinsBindingSpecBuilder(jenkinsBindingSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsBindingSpecObjectNested withNewJenkinsBindingSpecObject(){
            return new JenkinsBindingSpecObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsBindingSpecObjectNested withNewJenkinsBindingSpecObjectLike(JenkinsBindingSpec item){
            return new JenkinsBindingSpecObjectNestedImpl(item);
    }

    public A withPodSecurityContextObject(PodSecurityContext podSecurityContextObject){
            _visitables.remove(this.object);
            if (podSecurityContextObject!=null){ this.object= new PodSecurityContextBuilder(podSecurityContextObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodSecurityContextObjectNested withNewPodSecurityContextObject(){
            return new PodSecurityContextObjectNestedImpl();
    }

    public WatchEventFluent.PodSecurityContextObjectNested withNewPodSecurityContextObjectLike(PodSecurityContext item){
            return new PodSecurityContextObjectNestedImpl(item);
    }

    public A withNodeSystemInfoObject(NodeSystemInfo nodeSystemInfoObject){
            _visitables.remove(this.object);
            if (nodeSystemInfoObject!=null){ this.object= new NodeSystemInfoBuilder(nodeSystemInfoObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeSystemInfoObjectNested withNewNodeSystemInfoObject(){
            return new NodeSystemInfoObjectNestedImpl();
    }

    public WatchEventFluent.NodeSystemInfoObjectNested withNewNodeSystemInfoObjectLike(NodeSystemInfo item){
            return new NodeSystemInfoObjectNestedImpl(item);
    }

    public A withReplicationControllerObject(ReplicationController replicationControllerObject){
            _visitables.remove(this.object);
            if (replicationControllerObject!=null){ this.object= new ReplicationControllerBuilder(replicationControllerObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicationControllerObjectNested withNewReplicationControllerObject(){
            return new ReplicationControllerObjectNestedImpl();
    }

    public WatchEventFluent.ReplicationControllerObjectNested withNewReplicationControllerObjectLike(ReplicationController item){
            return new ReplicationControllerObjectNestedImpl(item);
    }

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

    public WatchEventFluent.CustomResourceDefinitionListObjectNested withNewCustomResourceDefinitionListObject(){
            return new CustomResourceDefinitionListObjectNestedImpl();
    }

    public WatchEventFluent.CustomResourceDefinitionListObjectNested withNewCustomResourceDefinitionListObjectLike(CustomResourceDefinitionList item){
            return new CustomResourceDefinitionListObjectNestedImpl(item);
    }

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

    public WatchEventFluent.EndpointsObjectNested withNewEndpointsObject(){
            return new EndpointsObjectNestedImpl();
    }

    public WatchEventFluent.EndpointsObjectNested withNewEndpointsObjectLike(Endpoints item){
            return new EndpointsObjectNestedImpl(item);
    }

    public A withNodeSelectorRequirementObject(NodeSelectorRequirement nodeSelectorRequirementObject){
            _visitables.remove(this.object);
            if (nodeSelectorRequirementObject!=null){ this.object= new NodeSelectorRequirementBuilder(nodeSelectorRequirementObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeSelectorRequirementObjectNested withNewNodeSelectorRequirementObject(){
            return new NodeSelectorRequirementObjectNestedImpl();
    }

    public WatchEventFluent.NodeSelectorRequirementObjectNested withNewNodeSelectorRequirementObjectLike(NodeSelectorRequirement item){
            return new NodeSelectorRequirementObjectNestedImpl(item);
    }

    public A withLimitRangeObject(LimitRange limitRangeObject){
            _visitables.remove(this.object);
            if (limitRangeObject!=null){ this.object= new LimitRangeBuilder(limitRangeObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LimitRangeObjectNested withNewLimitRangeObject(){
            return new LimitRangeObjectNestedImpl();
    }

    public WatchEventFluent.LimitRangeObjectNested withNewLimitRangeObjectLike(LimitRange item){
            return new LimitRangeObjectNestedImpl(item);
    }

    public A withLocalObjectReferenceObject(LocalObjectReference localObjectReferenceObject){
            _visitables.remove(this.object);
            if (localObjectReferenceObject!=null){ this.object= new LocalObjectReferenceBuilder(localObjectReferenceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LocalObjectReferenceObjectNested withNewLocalObjectReferenceObject(){
            return new LocalObjectReferenceObjectNestedImpl();
    }

    public WatchEventFluent.LocalObjectReferenceObjectNested withNewLocalObjectReferenceObjectLike(LocalObjectReference item){
            return new LocalObjectReferenceObjectNestedImpl(item);
    }

    public A withNewLocalObjectReferenceObject(String name){
            return (A)withLocalObjectReferenceObject(new LocalObjectReference(name));
    }

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

    public WatchEventFluent.CustomResourceDefinitionConditionObjectNested withNewCustomResourceDefinitionConditionObject(){
            return new CustomResourceDefinitionConditionObjectNestedImpl();
    }

    public WatchEventFluent.CustomResourceDefinitionConditionObjectNested withNewCustomResourceDefinitionConditionObjectLike(CustomResourceDefinitionCondition item){
            return new CustomResourceDefinitionConditionObjectNestedImpl(item);
    }

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

    public A withRootPathsObject(RootPaths rootPathsObject){
            _visitables.remove(this.object);
            if (rootPathsObject!=null){ this.object= new RootPathsBuilder(rootPathsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RootPathsObjectNested withNewRootPathsObject(){
            return new RootPathsObjectNestedImpl();
    }

    public WatchEventFluent.RootPathsObjectNested withNewRootPathsObjectLike(RootPaths item){
            return new RootPathsObjectNestedImpl(item);
    }

    public A withVsphereVirtualDiskVolumeSourceObject(VsphereVirtualDiskVolumeSource vsphereVirtualDiskVolumeSourceObject){
            _visitables.remove(this.object);
            if (vsphereVirtualDiskVolumeSourceObject!=null){ this.object= new VsphereVirtualDiskVolumeSourceBuilder(vsphereVirtualDiskVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.VsphereVirtualDiskVolumeSourceObjectNested withNewVsphereVirtualDiskVolumeSourceObject(){
            return new VsphereVirtualDiskVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.VsphereVirtualDiskVolumeSourceObjectNested withNewVsphereVirtualDiskVolumeSourceObjectLike(VsphereVirtualDiskVolumeSource item){
            return new VsphereVirtualDiskVolumeSourceObjectNestedImpl(item);
    }

    public A withNewVsphereVirtualDiskVolumeSourceObject(String fsType,String storagePolicyID,String storagePolicyName,String volumePath){
            return (A)withVsphereVirtualDiskVolumeSourceObject(new VsphereVirtualDiskVolumeSource(fsType, storagePolicyID, storagePolicyName, volumePath));
    }

    public A withDaemonEndpointObject(DaemonEndpoint daemonEndpointObject){
            _visitables.remove(this.object);
            if (daemonEndpointObject!=null){ this.object= new DaemonEndpointBuilder(daemonEndpointObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DaemonEndpointObjectNested withNewDaemonEndpointObject(){
            return new DaemonEndpointObjectNestedImpl();
    }

    public WatchEventFluent.DaemonEndpointObjectNested withNewDaemonEndpointObjectLike(DaemonEndpoint item){
            return new DaemonEndpointObjectNestedImpl(item);
    }

    public A withNewDaemonEndpointObject(Integer port){
            return (A)withDaemonEndpointObject(new DaemonEndpoint(port));
    }

    public A withKubernetesListObject(KubernetesList kubernetesListObject){
            _visitables.remove(this.object);
            if (kubernetesListObject!=null){ this.object= new KubernetesListBuilder(kubernetesListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.KubernetesListObjectNested withNewKubernetesListObject(){
            return new KubernetesListObjectNestedImpl();
    }

    public WatchEventFluent.KubernetesListObjectNested withNewKubernetesListObjectLike(KubernetesList item){
            return new KubernetesListObjectNestedImpl(item);
    }

    public A withSecretKeySetRefObject(SecretKeySetRef secretKeySetRefObject){
            _visitables.remove(this.object);
            if (secretKeySetRefObject!=null){ this.object= new SecretKeySetRefBuilder(secretKeySetRefObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretKeySetRefObjectNested withNewSecretKeySetRefObject(){
            return new SecretKeySetRefObjectNestedImpl();
    }

    public WatchEventFluent.SecretKeySetRefObjectNested withNewSecretKeySetRefObjectLike(SecretKeySetRef item){
            return new SecretKeySetRefObjectNestedImpl(item);
    }

    public A withNewSecretKeySetRefObject(String apiTokenKey,String name,String namespace,String usernameKey){
            return (A)withSecretKeySetRefObject(new SecretKeySetRef(apiTokenKey, name, namespace, usernameKey));
    }

    public A withTokenReviewStatusObject(TokenReviewStatus tokenReviewStatusObject){
            _visitables.remove(this.object);
            if (tokenReviewStatusObject!=null){ this.object= new TokenReviewStatusBuilder(tokenReviewStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.TokenReviewStatusObjectNested withNewTokenReviewStatusObject(){
            return new TokenReviewStatusObjectNestedImpl();
    }

    public WatchEventFluent.TokenReviewStatusObjectNested withNewTokenReviewStatusObjectLike(TokenReviewStatus item){
            return new TokenReviewStatusObjectNestedImpl(item);
    }

    public A withCodeRepositoryStatusRepositoryObject(CodeRepositoryStatusRepository codeRepositoryStatusRepositoryObject){
            _visitables.remove(this.object);
            if (codeRepositoryStatusRepositoryObject!=null){ this.object= new CodeRepositoryStatusRepositoryBuilder(codeRepositoryStatusRepositoryObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositoryStatusRepositoryObjectNested withNewCodeRepositoryStatusRepositoryObject(){
            return new CodeRepositoryStatusRepositoryObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositoryStatusRepositoryObjectNested withNewCodeRepositoryStatusRepositoryObjectLike(CodeRepositoryStatusRepository item){
            return new CodeRepositoryStatusRepositoryObjectNestedImpl(item);
    }

    public A withEventSourceObject(EventSource eventSourceObject){
            _visitables.remove(this.object);
            if (eventSourceObject!=null){ this.object= new EventSourceBuilder(eventSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EventSourceObjectNested withNewEventSourceObject(){
            return new EventSourceObjectNestedImpl();
    }

    public WatchEventFluent.EventSourceObjectNested withNewEventSourceObjectLike(EventSource item){
            return new EventSourceObjectNestedImpl(item);
    }

    public A withNewEventSourceObject(String component,String host){
            return (A)withEventSourceObject(new EventSource(component, host));
    }

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

    public WatchEventFluent.NetworkPolicyObjectNested withNewNetworkPolicyObject(){
            return new NetworkPolicyObjectNestedImpl();
    }

    public WatchEventFluent.NetworkPolicyObjectNested withNewNetworkPolicyObjectLike(NetworkPolicy item){
            return new NetworkPolicyObjectNestedImpl(item);
    }

    public A withContainerStateObject(ContainerState containerStateObject){
            _visitables.remove(this.object);
            if (containerStateObject!=null){ this.object= new ContainerStateBuilder(containerStateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerStateObjectNested withNewContainerStateObject(){
            return new ContainerStateObjectNestedImpl();
    }

    public WatchEventFluent.ContainerStateObjectNested withNewContainerStateObjectLike(ContainerState item){
            return new ContainerStateObjectNestedImpl(item);
    }

    public A withAPIVersionObject(APIVersion aPIVersionObject){
            _visitables.remove(this.object);
            if (aPIVersionObject!=null){ this.object= new APIVersionBuilder(aPIVersionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.APIVersionObjectNested withNewAPIVersionObject(){
            return new APIVersionObjectNestedImpl();
    }

    public WatchEventFluent.APIVersionObjectNested withNewAPIVersionObjectLike(APIVersion item){
            return new APIVersionObjectNestedImpl(item);
    }

    public A withNewAPIVersionObject(String name){
            return (A)withAPIVersionObject(new APIVersion(name));
    }

    public A withProjectNamespaceObject(ProjectNamespace projectNamespaceObject){
            _visitables.remove(this.object);
            if (projectNamespaceObject!=null){ this.object= new ProjectNamespaceBuilder(projectNamespaceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectNamespaceObjectNested withNewProjectNamespaceObject(){
            return new ProjectNamespaceObjectNestedImpl();
    }

    public WatchEventFluent.ProjectNamespaceObjectNested withNewProjectNamespaceObjectLike(ProjectNamespace item){
            return new ProjectNamespaceObjectNestedImpl(item);
    }

    public A withNewProjectNamespaceObject(String name,String type){
            return (A)withProjectNamespaceObject(new ProjectNamespace(name, type));
    }

    public A withProjectSpecObject(ProjectSpec projectSpecObject){
            _visitables.remove(this.object);
            if (projectSpecObject!=null){ this.object= new ProjectSpecBuilder(projectSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectSpecObjectNested withNewProjectSpecObject(){
            return new ProjectSpecObjectNestedImpl();
    }

    public WatchEventFluent.ProjectSpecObjectNested withNewProjectSpecObjectLike(ProjectSpec item){
            return new ProjectSpecObjectNestedImpl(item);
    }

    public A withHTTPHeaderObject(HTTPHeader hTTPHeaderObject){
            _visitables.remove(this.object);
            if (hTTPHeaderObject!=null){ this.object= new HTTPHeaderBuilder(hTTPHeaderObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HTTPHeaderObjectNested withNewHTTPHeaderObject(){
            return new HTTPHeaderObjectNestedImpl();
    }

    public WatchEventFluent.HTTPHeaderObjectNested withNewHTTPHeaderObjectLike(HTTPHeader item){
            return new HTTPHeaderObjectNestedImpl(item);
    }

    public A withNewHTTPHeaderObject(String name,String value){
            return (A)withHTTPHeaderObject(new HTTPHeader(name, value));
    }

    public A withServiceObject(Service serviceObject){
            _visitables.remove(this.object);
            if (serviceObject!=null){ this.object= new ServiceBuilder(serviceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServiceObjectNested withNewServiceObject(){
            return new ServiceObjectNestedImpl();
    }

    public WatchEventFluent.ServiceObjectNested withNewServiceObjectLike(Service item){
            return new ServiceObjectNestedImpl(item);
    }

    public A withNetworkPolicyPortObject(NetworkPolicyPort networkPolicyPortObject){
            _visitables.remove(this.object);
            if (networkPolicyPortObject!=null){ this.object= new NetworkPolicyPortBuilder(networkPolicyPortObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NetworkPolicyPortObjectNested withNewNetworkPolicyPortObject(){
            return new NetworkPolicyPortObjectNestedImpl();
    }

    public WatchEventFluent.NetworkPolicyPortObjectNested withNewNetworkPolicyPortObjectLike(NetworkPolicyPort item){
            return new NetworkPolicyPortObjectNestedImpl(item);
    }

    public A withIngressTLSObject(IngressTLS ingressTLSObject){
            _visitables.remove(this.object);
            if (ingressTLSObject!=null){ this.object= new IngressTLSBuilder(ingressTLSObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.IngressTLSObjectNested withNewIngressTLSObject(){
            return new IngressTLSObjectNestedImpl();
    }

    public WatchEventFluent.IngressTLSObjectNested withNewIngressTLSObjectLike(IngressTLS item){
            return new IngressTLSObjectNestedImpl(item);
    }

    public A withPipelineTemplateArgumentObject(PipelineTemplateArgument pipelineTemplateArgumentObject){
            _visitables.remove(this.object);
            if (pipelineTemplateArgumentObject!=null){ this.object= new PipelineTemplateArgumentBuilder(pipelineTemplateArgumentObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateArgumentObjectNested withNewPipelineTemplateArgumentObject(){
            return new PipelineTemplateArgumentObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateArgumentObjectNested withNewPipelineTemplateArgumentObjectLike(PipelineTemplateArgument item){
            return new PipelineTemplateArgumentObjectNestedImpl(item);
    }

    public A withVolumeProjectionObject(VolumeProjection volumeProjectionObject){
            _visitables.remove(this.object);
            if (volumeProjectionObject!=null){ this.object= new VolumeProjectionBuilder(volumeProjectionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.VolumeProjectionObjectNested withNewVolumeProjectionObject(){
            return new VolumeProjectionObjectNestedImpl();
    }

    public WatchEventFluent.VolumeProjectionObjectNested withNewVolumeProjectionObjectLike(VolumeProjection item){
            return new VolumeProjectionObjectNestedImpl(item);
    }

    public A withPersistentVolumeSpecObject(PersistentVolumeSpec persistentVolumeSpecObject){
            _visitables.remove(this.object);
            if (persistentVolumeSpecObject!=null){ this.object= new PersistentVolumeSpecBuilder(persistentVolumeSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PersistentVolumeSpecObjectNested withNewPersistentVolumeSpecObject(){
            return new PersistentVolumeSpecObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeSpecObjectNested withNewPersistentVolumeSpecObjectLike(PersistentVolumeSpec item){
            return new PersistentVolumeSpecObjectNestedImpl(item);
    }

    public A withSecretEnvSourceObject(SecretEnvSource secretEnvSourceObject){
            _visitables.remove(this.object);
            if (secretEnvSourceObject!=null){ this.object= new SecretEnvSourceBuilder(secretEnvSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretEnvSourceObjectNested withNewSecretEnvSourceObject(){
            return new SecretEnvSourceObjectNestedImpl();
    }

    public WatchEventFluent.SecretEnvSourceObjectNested withNewSecretEnvSourceObjectLike(SecretEnvSource item){
            return new SecretEnvSourceObjectNestedImpl(item);
    }

    public A withNewSecretEnvSourceObject(String name,Boolean optional){
            return (A)withSecretEnvSourceObject(new SecretEnvSource(name, optional));
    }

    public A withNFSVolumeSourceObject(NFSVolumeSource nFSVolumeSourceObject){
            _visitables.remove(this.object);
            if (nFSVolumeSourceObject!=null){ this.object= new NFSVolumeSourceBuilder(nFSVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NFSVolumeSourceObjectNested withNewNFSVolumeSourceObject(){
            return new NFSVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.NFSVolumeSourceObjectNested withNewNFSVolumeSourceObjectLike(NFSVolumeSource item){
            return new NFSVolumeSourceObjectNestedImpl(item);
    }

    public A withNewNFSVolumeSourceObject(String path,Boolean readOnly,String server){
            return (A)withNFSVolumeSourceObject(new NFSVolumeSource(path, readOnly, server));
    }

    public A withEventObject(Event eventObject){
            _visitables.remove(this.object);
            if (eventObject!=null){ this.object= new EventBuilder(eventObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EventObjectNested withNewEventObject(){
            return new EventObjectNestedImpl();
    }

    public WatchEventFluent.EventObjectNested withNewEventObjectLike(Event item){
            return new EventObjectNestedImpl(item);
    }

    public A withObjectFieldSelectorObject(ObjectFieldSelector objectFieldSelectorObject){
            _visitables.remove(this.object);
            if (objectFieldSelectorObject!=null){ this.object= new ObjectFieldSelectorBuilder(objectFieldSelectorObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ObjectFieldSelectorObjectNested withNewObjectFieldSelectorObject(){
            return new ObjectFieldSelectorObjectNestedImpl();
    }

    public WatchEventFluent.ObjectFieldSelectorObjectNested withNewObjectFieldSelectorObjectLike(ObjectFieldSelector item){
            return new ObjectFieldSelectorObjectNestedImpl(item);
    }

    public A withNewObjectFieldSelectorObject(String apiVersion,String fieldPath){
            return (A)withObjectFieldSelectorObject(new ObjectFieldSelector(apiVersion, fieldPath));
    }

    public A withIngressSpecObject(IngressSpec ingressSpecObject){
            _visitables.remove(this.object);
            if (ingressSpecObject!=null){ this.object= new IngressSpecBuilder(ingressSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.IngressSpecObjectNested withNewIngressSpecObject(){
            return new IngressSpecObjectNestedImpl();
    }

    public WatchEventFluent.IngressSpecObjectNested withNewIngressSpecObjectLike(IngressSpec item){
            return new IngressSpecObjectNestedImpl(item);
    }

    public A withNamespaceStatusObject(NamespaceStatus namespaceStatusObject){
            _visitables.remove(this.object);
            if (namespaceStatusObject!=null){ this.object= new NamespaceStatusBuilder(namespaceStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NamespaceStatusObjectNested withNewNamespaceStatusObject(){
            return new NamespaceStatusObjectNestedImpl();
    }

    public WatchEventFluent.NamespaceStatusObjectNested withNewNamespaceStatusObjectLike(NamespaceStatus item){
            return new NamespaceStatusObjectNestedImpl(item);
    }

    public A withNewNamespaceStatusObject(String phase){
            return (A)withNamespaceStatusObject(new NamespaceStatus(phase));
    }

    public A withSecurityContextObject(SecurityContext securityContextObject){
            _visitables.remove(this.object);
            if (securityContextObject!=null){ this.object= new SecurityContextBuilder(securityContextObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecurityContextObjectNested withNewSecurityContextObject(){
            return new SecurityContextObjectNestedImpl();
    }

    public WatchEventFluent.SecurityContextObjectNested withNewSecurityContextObjectLike(SecurityContext item){
            return new SecurityContextObjectNestedImpl(item);
    }

    public A withJenkinsBindingStatusObject(JenkinsBindingStatus jenkinsBindingStatusObject){
            _visitables.remove(this.object);
            if (jenkinsBindingStatusObject!=null){ this.object= new JenkinsBindingStatusBuilder(jenkinsBindingStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JenkinsBindingStatusObjectNested withNewJenkinsBindingStatusObject(){
            return new JenkinsBindingStatusObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsBindingStatusObjectNested withNewJenkinsBindingStatusObjectLike(JenkinsBindingStatus item){
            return new JenkinsBindingStatusObjectNestedImpl(item);
    }

    public A withPodDisruptionBudgetSpecObject(PodDisruptionBudgetSpec podDisruptionBudgetSpecObject){
            _visitables.remove(this.object);
            if (podDisruptionBudgetSpecObject!=null){ this.object= new PodDisruptionBudgetSpecBuilder(podDisruptionBudgetSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodDisruptionBudgetSpecObjectNested withNewPodDisruptionBudgetSpecObject(){
            return new PodDisruptionBudgetSpecObjectNestedImpl();
    }

    public WatchEventFluent.PodDisruptionBudgetSpecObjectNested withNewPodDisruptionBudgetSpecObjectLike(PodDisruptionBudgetSpec item){
            return new PodDisruptionBudgetSpecObjectNestedImpl(item);
    }

    public A withCodeRepositoryListObject(CodeRepositoryList codeRepositoryListObject){
            _visitables.remove(this.object);
            if (codeRepositoryListObject!=null){ this.object= new CodeRepositoryListBuilder(codeRepositoryListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositoryListObjectNested withNewCodeRepositoryListObject(){
            return new CodeRepositoryListObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositoryListObjectNested withNewCodeRepositoryListObjectLike(CodeRepositoryList item){
            return new CodeRepositoryListObjectNestedImpl(item);
    }

    public A withTaintObject(Taint taintObject){
            _visitables.remove(this.object);
            if (taintObject!=null){ this.object= new TaintBuilder(taintObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.TaintObjectNested withNewTaintObject(){
            return new TaintObjectNestedImpl();
    }

    public WatchEventFluent.TaintObjectNested withNewTaintObjectLike(Taint item){
            return new TaintObjectNestedImpl(item);
    }

    public A withNewTaintObject(String effect,String key,String timeAdded,String value){
            return (A)withTaintObject(new Taint(effect, key, timeAdded, value));
    }

    public A withPodSecurityPolicySpecObject(PodSecurityPolicySpec podSecurityPolicySpecObject){
            _visitables.remove(this.object);
            if (podSecurityPolicySpecObject!=null){ this.object= new PodSecurityPolicySpecBuilder(podSecurityPolicySpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodSecurityPolicySpecObjectNested withNewPodSecurityPolicySpecObject(){
            return new PodSecurityPolicySpecObjectNestedImpl();
    }

    public WatchEventFluent.PodSecurityPolicySpecObjectNested withNewPodSecurityPolicySpecObjectLike(PodSecurityPolicySpec item){
            return new PodSecurityPolicySpecObjectNestedImpl(item);
    }

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

    public WatchEventFluent.CustomResourceDefinitionNamesObjectNested withNewCustomResourceDefinitionNamesObject(){
            return new CustomResourceDefinitionNamesObjectNestedImpl();
    }

    public WatchEventFluent.CustomResourceDefinitionNamesObjectNested withNewCustomResourceDefinitionNamesObjectLike(CustomResourceDefinitionNames item){
            return new CustomResourceDefinitionNamesObjectNestedImpl(item);
    }

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

    public WatchEventFluent.NodeObjectNested withNewNodeObject(){
            return new NodeObjectNestedImpl();
    }

    public WatchEventFluent.NodeObjectNested withNewNodeObjectLike(Node item){
            return new NodeObjectNestedImpl(item);
    }

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

    public WatchEventFluent.InfoObjectNested withNewInfoObject(){
            return new InfoObjectNestedImpl();
    }

    public WatchEventFluent.InfoObjectNested withNewInfoObjectLike(Info item){
            return new InfoObjectNestedImpl(item);
    }

    public A withTCPSocketActionObject(TCPSocketAction tCPSocketActionObject){
            _visitables.remove(this.object);
            if (tCPSocketActionObject!=null){ this.object= new TCPSocketActionBuilder(tCPSocketActionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.TCPSocketActionObjectNested withNewTCPSocketActionObject(){
            return new TCPSocketActionObjectNestedImpl();
    }

    public WatchEventFluent.TCPSocketActionObjectNested withNewTCPSocketActionObjectLike(TCPSocketAction item){
            return new TCPSocketActionObjectNestedImpl(item);
    }

    public A withEnvFromSourceObject(EnvFromSource envFromSourceObject){
            _visitables.remove(this.object);
            if (envFromSourceObject!=null){ this.object= new EnvFromSourceBuilder(envFromSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EnvFromSourceObjectNested withNewEnvFromSourceObject(){
            return new EnvFromSourceObjectNestedImpl();
    }

    public WatchEventFluent.EnvFromSourceObjectNested withNewEnvFromSourceObjectLike(EnvFromSource item){
            return new EnvFromSourceObjectNestedImpl(item);
    }

    public A withKeyToPathObject(KeyToPath keyToPathObject){
            _visitables.remove(this.object);
            if (keyToPathObject!=null){ this.object= new KeyToPathBuilder(keyToPathObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.KeyToPathObjectNested withNewKeyToPathObject(){
            return new KeyToPathObjectNestedImpl();
    }

    public WatchEventFluent.KeyToPathObjectNested withNewKeyToPathObjectLike(KeyToPath item){
            return new KeyToPathObjectNestedImpl(item);
    }

    public A withNewKeyToPathObject(String key,Integer mode,String path){
            return (A)withKeyToPathObject(new KeyToPath(key, mode, path));
    }

    public A withReplicaSetObject(ReplicaSet replicaSetObject){
            _visitables.remove(this.object);
            if (replicaSetObject!=null){ this.object= new ReplicaSetBuilder(replicaSetObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicaSetObjectNested withNewReplicaSetObject(){
            return new ReplicaSetObjectNestedImpl();
    }

    public WatchEventFluent.ReplicaSetObjectNested withNewReplicaSetObjectLike(ReplicaSet item){
            return new ReplicaSetObjectNestedImpl(item);
    }

    public A withNodeSelectorTermObject(NodeSelectorTerm nodeSelectorTermObject){
            _visitables.remove(this.object);
            if (nodeSelectorTermObject!=null){ this.object= new NodeSelectorTermBuilder(nodeSelectorTermObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeSelectorTermObjectNested withNewNodeSelectorTermObject(){
            return new NodeSelectorTermObjectNestedImpl();
    }

    public WatchEventFluent.NodeSelectorTermObjectNested withNewNodeSelectorTermObjectLike(NodeSelectorTerm item){
            return new NodeSelectorTermObjectNestedImpl(item);
    }

    public A withSubjectAccessReviewStatusObject(SubjectAccessReviewStatus subjectAccessReviewStatusObject){
            _visitables.remove(this.object);
            if (subjectAccessReviewStatusObject!=null){ this.object= new SubjectAccessReviewStatusBuilder(subjectAccessReviewStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SubjectAccessReviewStatusObjectNested withNewSubjectAccessReviewStatusObject(){
            return new SubjectAccessReviewStatusObjectNestedImpl();
    }

    public WatchEventFluent.SubjectAccessReviewStatusObjectNested withNewSubjectAccessReviewStatusObjectLike(SubjectAccessReviewStatus item){
            return new SubjectAccessReviewStatusObjectNestedImpl(item);
    }

    public A withNewSubjectAccessReviewStatusObject(Boolean allowed,String evaluationError,String reason){
            return (A)withSubjectAccessReviewStatusObject(new SubjectAccessReviewStatus(allowed, evaluationError, reason));
    }

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

    public WatchEventFluent.DeploymentListObjectNested withNewDeploymentListObject(){
            return new DeploymentListObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentListObjectNested withNewDeploymentListObjectLike(DeploymentList item){
            return new DeploymentListObjectNestedImpl(item);
    }

    public A withPersistentVolumeClaimSpecObject(PersistentVolumeClaimSpec persistentVolumeClaimSpecObject){
            _visitables.remove(this.object);
            if (persistentVolumeClaimSpecObject!=null){ this.object= new PersistentVolumeClaimSpecBuilder(persistentVolumeClaimSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PersistentVolumeClaimSpecObjectNested withNewPersistentVolumeClaimSpecObject(){
            return new PersistentVolumeClaimSpecObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeClaimSpecObjectNested withNewPersistentVolumeClaimSpecObjectLike(PersistentVolumeClaimSpec item){
            return new PersistentVolumeClaimSpecObjectNestedImpl(item);
    }

    public A withNamespaceSpecObject(NamespaceSpec namespaceSpecObject){
            _visitables.remove(this.object);
            if (namespaceSpecObject!=null){ this.object= new NamespaceSpecBuilder(namespaceSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NamespaceSpecObjectNested withNewNamespaceSpecObject(){
            return new NamespaceSpecObjectNestedImpl();
    }

    public WatchEventFluent.NamespaceSpecObjectNested withNewNamespaceSpecObjectLike(NamespaceSpec item){
            return new NamespaceSpecObjectNestedImpl(item);
    }

    public A withPipelineTaskArgumentDisplayObject(PipelineTaskArgumentDisplay pipelineTaskArgumentDisplayObject){
            _visitables.remove(this.object);
            if (pipelineTaskArgumentDisplayObject!=null){ this.object= new PipelineTaskArgumentDisplayBuilder(pipelineTaskArgumentDisplayObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskArgumentDisplayObjectNested withNewPipelineTaskArgumentDisplayObject(){
            return new PipelineTaskArgumentDisplayObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskArgumentDisplayObjectNested withNewPipelineTaskArgumentDisplayObjectLike(PipelineTaskArgumentDisplay item){
            return new PipelineTaskArgumentDisplayObjectNestedImpl(item);
    }

    public A withEndpointSubsetObject(EndpointSubset endpointSubsetObject){
            _visitables.remove(this.object);
            if (endpointSubsetObject!=null){ this.object= new EndpointSubsetBuilder(endpointSubsetObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EndpointSubsetObjectNested withNewEndpointSubsetObject(){
            return new EndpointSubsetObjectNestedImpl();
    }

    public WatchEventFluent.EndpointSubsetObjectNested withNewEndpointSubsetObjectLike(EndpointSubset item){
            return new EndpointSubsetObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PatchObjectNested withNewPatchObject(){
            return new PatchObjectNestedImpl();
    }

    public WatchEventFluent.PatchObjectNested withNewPatchObjectLike(Patch item){
            return new PatchObjectNestedImpl(item);
    }

    public A withJobTemplateSpecObject(JobTemplateSpec jobTemplateSpecObject){
            _visitables.remove(this.object);
            if (jobTemplateSpecObject!=null){ this.object= new JobTemplateSpecBuilder(jobTemplateSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JobTemplateSpecObjectNested withNewJobTemplateSpecObject(){
            return new JobTemplateSpecObjectNestedImpl();
    }

    public WatchEventFluent.JobTemplateSpecObjectNested withNewJobTemplateSpecObjectLike(JobTemplateSpec item){
            return new JobTemplateSpecObjectNestedImpl(item);
    }

    public A withLoadBalancerStatusObject(LoadBalancerStatus loadBalancerStatusObject){
            _visitables.remove(this.object);
            if (loadBalancerStatusObject!=null){ this.object= new LoadBalancerStatusBuilder(loadBalancerStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LoadBalancerStatusObjectNested withNewLoadBalancerStatusObject(){
            return new LoadBalancerStatusObjectNestedImpl();
    }

    public WatchEventFluent.LoadBalancerStatusObjectNested withNewLoadBalancerStatusObjectLike(LoadBalancerStatus item){
            return new LoadBalancerStatusObjectNestedImpl(item);
    }

    public A withReplicaSetStatusObject(ReplicaSetStatus replicaSetStatusObject){
            _visitables.remove(this.object);
            if (replicaSetStatusObject!=null){ this.object= new ReplicaSetStatusBuilder(replicaSetStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicaSetStatusObjectNested withNewReplicaSetStatusObject(){
            return new ReplicaSetStatusObjectNestedImpl();
    }

    public WatchEventFluent.ReplicaSetStatusObjectNested withNewReplicaSetStatusObjectLike(ReplicaSetStatus item){
            return new ReplicaSetStatusObjectNestedImpl(item);
    }

    public A withClusterPipelineTemplateObject(ClusterPipelineTemplate clusterPipelineTemplateObject){
            _visitables.remove(this.object);
            if (clusterPipelineTemplateObject!=null){ this.object= new ClusterPipelineTemplateBuilder(clusterPipelineTemplateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ClusterPipelineTemplateObjectNested withNewClusterPipelineTemplateObject(){
            return new ClusterPipelineTemplateObjectNestedImpl();
    }

    public WatchEventFluent.ClusterPipelineTemplateObjectNested withNewClusterPipelineTemplateObjectLike(ClusterPipelineTemplate item){
            return new ClusterPipelineTemplateObjectNestedImpl(item);
    }

    public A withPipelineConfigTemplateSpecObject(PipelineConfigTemplateSpec pipelineConfigTemplateSpecObject){
            _visitables.remove(this.object);
            if (pipelineConfigTemplateSpecObject!=null){ this.object= new PipelineConfigTemplateSpecBuilder(pipelineConfigTemplateSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineConfigTemplateSpecObjectNested withNewPipelineConfigTemplateSpecObject(){
            return new PipelineConfigTemplateSpecObjectNestedImpl();
    }

    public WatchEventFluent.PipelineConfigTemplateSpecObjectNested withNewPipelineConfigTemplateSpecObjectLike(PipelineConfigTemplateSpec item){
            return new PipelineConfigTemplateSpecObjectNestedImpl(item);
    }

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

    public WatchEventFluent.DaemonSetListObjectNested withNewDaemonSetListObject(){
            return new DaemonSetListObjectNestedImpl();
    }

    public WatchEventFluent.DaemonSetListObjectNested withNewDaemonSetListObjectLike(DaemonSetList item){
            return new DaemonSetListObjectNestedImpl(item);
    }

    public A withHorizontalPodAutoscalerStatusObject(HorizontalPodAutoscalerStatus horizontalPodAutoscalerStatusObject){
            _visitables.remove(this.object);
            if (horizontalPodAutoscalerStatusObject!=null){ this.object= new HorizontalPodAutoscalerStatusBuilder(horizontalPodAutoscalerStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HorizontalPodAutoscalerStatusObjectNested withNewHorizontalPodAutoscalerStatusObject(){
            return new HorizontalPodAutoscalerStatusObjectNestedImpl();
    }

    public WatchEventFluent.HorizontalPodAutoscalerStatusObjectNested withNewHorizontalPodAutoscalerStatusObjectLike(HorizontalPodAutoscalerStatus item){
            return new HorizontalPodAutoscalerStatusObjectNestedImpl(item);
    }

    public A withNewHorizontalPodAutoscalerStatusObject(Integer currentCPUUtilizationPercentage,Integer currentReplicas,Integer desiredReplicas,String lastScaleTime,Long observedGeneration){
            return (A)withHorizontalPodAutoscalerStatusObject(new HorizontalPodAutoscalerStatus(currentCPUUtilizationPercentage, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration));
    }

    public A withSubjectAccessReviewSpecObject(SubjectAccessReviewSpec subjectAccessReviewSpecObject){
            _visitables.remove(this.object);
            if (subjectAccessReviewSpecObject!=null){ this.object= new SubjectAccessReviewSpecBuilder(subjectAccessReviewSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SubjectAccessReviewSpecObjectNested withNewSubjectAccessReviewSpecObject(){
            return new SubjectAccessReviewSpecObjectNestedImpl();
    }

    public WatchEventFluent.SubjectAccessReviewSpecObjectNested withNewSubjectAccessReviewSpecObjectLike(SubjectAccessReviewSpec item){
            return new SubjectAccessReviewSpecObjectNestedImpl(item);
    }

    public A withLifecycleObject(Lifecycle lifecycleObject){
            _visitables.remove(this.object);
            if (lifecycleObject!=null){ this.object= new LifecycleBuilder(lifecycleObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.LifecycleObjectNested withNewLifecycleObject(){
            return new LifecycleObjectNestedImpl();
    }

    public WatchEventFluent.LifecycleObjectNested withNewLifecycleObjectLike(Lifecycle item){
            return new LifecycleObjectNestedImpl(item);
    }

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

    public WatchEventFluent.JobObjectNested withNewJobObject(){
            return new JobObjectNestedImpl();
    }

    public WatchEventFluent.JobObjectNested withNewJobObjectLike(Job item){
            return new JobObjectNestedImpl(item);
    }

    public A withNamedAuthInfoObject(NamedAuthInfo namedAuthInfoObject){
            _visitables.remove(this.object);
            if (namedAuthInfoObject!=null){ this.object= new NamedAuthInfoBuilder(namedAuthInfoObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NamedAuthInfoObjectNested withNewNamedAuthInfoObject(){
            return new NamedAuthInfoObjectNestedImpl();
    }

    public WatchEventFluent.NamedAuthInfoObjectNested withNewNamedAuthInfoObjectLike(NamedAuthInfo item){
            return new NamedAuthInfoObjectNestedImpl(item);
    }

    public A withContainerImageObject(ContainerImage containerImageObject){
            _visitables.remove(this.object);
            if (containerImageObject!=null){ this.object= new ContainerImageBuilder(containerImageObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerImageObjectNested withNewContainerImageObject(){
            return new ContainerImageObjectNestedImpl();
    }

    public WatchEventFluent.ContainerImageObjectNested withNewContainerImageObjectLike(ContainerImage item){
            return new ContainerImageObjectNestedImpl(item);
    }

    public A withStatefulSetUpdateStrategyObject(StatefulSetUpdateStrategy statefulSetUpdateStrategyObject){
            _visitables.remove(this.object);
            if (statefulSetUpdateStrategyObject!=null){ this.object= new StatefulSetUpdateStrategyBuilder(statefulSetUpdateStrategyObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatefulSetUpdateStrategyObjectNested withNewStatefulSetUpdateStrategyObject(){
            return new StatefulSetUpdateStrategyObjectNestedImpl();
    }

    public WatchEventFluent.StatefulSetUpdateStrategyObjectNested withNewStatefulSetUpdateStrategyObjectLike(StatefulSetUpdateStrategy item){
            return new StatefulSetUpdateStrategyObjectNestedImpl(item);
    }

    public A withPipelineTriggerCronObject(PipelineTriggerCron pipelineTriggerCronObject){
            _visitables.remove(this.object);
            if (pipelineTriggerCronObject!=null){ this.object= new PipelineTriggerCronBuilder(pipelineTriggerCronObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTriggerCronObjectNested withNewPipelineTriggerCronObject(){
            return new PipelineTriggerCronObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTriggerCronObjectNested withNewPipelineTriggerCronObjectLike(PipelineTriggerCron item){
            return new PipelineTriggerCronObjectNestedImpl(item);
    }

    public A withNonResourceAttributesObject(NonResourceAttributes nonResourceAttributesObject){
            _visitables.remove(this.object);
            if (nonResourceAttributesObject!=null){ this.object= new NonResourceAttributesBuilder(nonResourceAttributesObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NonResourceAttributesObjectNested withNewNonResourceAttributesObject(){
            return new NonResourceAttributesObjectNestedImpl();
    }

    public WatchEventFluent.NonResourceAttributesObjectNested withNewNonResourceAttributesObjectLike(NonResourceAttributes item){
            return new NonResourceAttributesObjectNestedImpl(item);
    }

    public A withNewNonResourceAttributesObject(String path,String verb){
            return (A)withNonResourceAttributesObject(new NonResourceAttributes(path, verb));
    }

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

    public WatchEventFluent.ObjectMetaObjectNested withNewObjectMetaObject(){
            return new ObjectMetaObjectNestedImpl();
    }

    public WatchEventFluent.ObjectMetaObjectNested withNewObjectMetaObjectLike(ObjectMeta item){
            return new ObjectMetaObjectNestedImpl(item);
    }

    public A withEnvVarSourceObject(EnvVarSource envVarSourceObject){
            _visitables.remove(this.object);
            if (envVarSourceObject!=null){ this.object= new EnvVarSourceBuilder(envVarSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EnvVarSourceObjectNested withNewEnvVarSourceObject(){
            return new EnvVarSourceObjectNestedImpl();
    }

    public WatchEventFluent.EnvVarSourceObjectNested withNewEnvVarSourceObjectLike(EnvVarSource item){
            return new EnvVarSourceObjectNestedImpl(item);
    }

    public A withRollingUpdateDaemonSetObject(RollingUpdateDaemonSet rollingUpdateDaemonSetObject){
            _visitables.remove(this.object);
            if (rollingUpdateDaemonSetObject!=null){ this.object= new RollingUpdateDaemonSetBuilder(rollingUpdateDaemonSetObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RollingUpdateDaemonSetObjectNested withNewRollingUpdateDaemonSetObject(){
            return new RollingUpdateDaemonSetObjectNestedImpl();
    }

    public WatchEventFluent.RollingUpdateDaemonSetObjectNested withNewRollingUpdateDaemonSetObjectLike(RollingUpdateDaemonSet item){
            return new RollingUpdateDaemonSetObjectNestedImpl(item);
    }

    public A withPhotonPersistentDiskVolumeSourceObject(PhotonPersistentDiskVolumeSource photonPersistentDiskVolumeSourceObject){
            _visitables.remove(this.object);
            if (photonPersistentDiskVolumeSourceObject!=null){ this.object= new PhotonPersistentDiskVolumeSourceBuilder(photonPersistentDiskVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested withNewPhotonPersistentDiskVolumeSourceObject(){
            return new PhotonPersistentDiskVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested withNewPhotonPersistentDiskVolumeSourceObjectLike(PhotonPersistentDiskVolumeSource item){
            return new PhotonPersistentDiskVolumeSourceObjectNestedImpl(item);
    }

    public A withNewPhotonPersistentDiskVolumeSourceObject(String fsType,String pdID){
            return (A)withPhotonPersistentDiskVolumeSourceObject(new PhotonPersistentDiskVolumeSource(fsType, pdID));
    }

    public A withReplicationControllerListObject(ReplicationControllerList replicationControllerListObject){
            _visitables.remove(this.object);
            if (replicationControllerListObject!=null){ this.object= new ReplicationControllerListBuilder(replicationControllerListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicationControllerListObjectNested withNewReplicationControllerListObject(){
            return new ReplicationControllerListObjectNestedImpl();
    }

    public WatchEventFluent.ReplicationControllerListObjectNested withNewReplicationControllerListObjectLike(ReplicationControllerList item){
            return new ReplicationControllerListObjectNestedImpl(item);
    }

    public A withHTTPIngressPathObject(HTTPIngressPath hTTPIngressPathObject){
            _visitables.remove(this.object);
            if (hTTPIngressPathObject!=null){ this.object= new HTTPIngressPathBuilder(hTTPIngressPathObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HTTPIngressPathObjectNested withNewHTTPIngressPathObject(){
            return new HTTPIngressPathObjectNestedImpl();
    }

    public WatchEventFluent.HTTPIngressPathObjectNested withNewHTTPIngressPathObjectLike(HTTPIngressPath item){
            return new HTTPIngressPathObjectNestedImpl(item);
    }

    public A withJobStatusObject(JobStatus jobStatusObject){
            _visitables.remove(this.object);
            if (jobStatusObject!=null){ this.object= new JobStatusBuilder(jobStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JobStatusObjectNested withNewJobStatusObject(){
            return new JobStatusObjectNestedImpl();
    }

    public WatchEventFluent.JobStatusObjectNested withNewJobStatusObjectLike(JobStatus item){
            return new JobStatusObjectNestedImpl(item);
    }

    public A withDownwardAPIVolumeFileObject(DownwardAPIVolumeFile downwardAPIVolumeFileObject){
            _visitables.remove(this.object);
            if (downwardAPIVolumeFileObject!=null){ this.object= new DownwardAPIVolumeFileBuilder(downwardAPIVolumeFileObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DownwardAPIVolumeFileObjectNested withNewDownwardAPIVolumeFileObject(){
            return new DownwardAPIVolumeFileObjectNestedImpl();
    }

    public WatchEventFluent.DownwardAPIVolumeFileObjectNested withNewDownwardAPIVolumeFileObjectLike(DownwardAPIVolumeFile item){
            return new DownwardAPIVolumeFileObjectNestedImpl(item);
    }

    public A withRollbackConfigObject(RollbackConfig rollbackConfigObject){
            _visitables.remove(this.object);
            if (rollbackConfigObject!=null){ this.object= new RollbackConfigBuilder(rollbackConfigObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RollbackConfigObjectNested withNewRollbackConfigObject(){
            return new RollbackConfigObjectNestedImpl();
    }

    public WatchEventFluent.RollbackConfigObjectNested withNewRollbackConfigObjectLike(RollbackConfig item){
            return new RollbackConfigObjectNestedImpl(item);
    }

    public A withNewRollbackConfigObject(Long revision){
            return (A)withRollbackConfigObject(new RollbackConfig(revision));
    }

    public A withCapabilitiesObject(Capabilities capabilitiesObject){
            _visitables.remove(this.object);
            if (capabilitiesObject!=null){ this.object= new CapabilitiesBuilder(capabilitiesObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CapabilitiesObjectNested withNewCapabilitiesObject(){
            return new CapabilitiesObjectNestedImpl();
    }

    public WatchEventFluent.CapabilitiesObjectNested withNewCapabilitiesObjectLike(Capabilities item){
            return new CapabilitiesObjectNestedImpl(item);
    }

    public A withPodAffinityObject(PodAffinity podAffinityObject){
            _visitables.remove(this.object);
            if (podAffinityObject!=null){ this.object= new PodAffinityBuilder(podAffinityObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodAffinityObjectNested withNewPodAffinityObject(){
            return new PodAffinityObjectNestedImpl();
    }

    public WatchEventFluent.PodAffinityObjectNested withNewPodAffinityObjectLike(PodAffinity item){
            return new PodAffinityObjectNestedImpl(item);
    }

    public A withServiceSpecObject(ServiceSpec serviceSpecObject){
            _visitables.remove(this.object);
            if (serviceSpecObject!=null){ this.object= new ServiceSpecBuilder(serviceSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ServiceSpecObjectNested withNewServiceSpecObject(){
            return new ServiceSpecObjectNestedImpl();
    }

    public WatchEventFluent.ServiceSpecObjectNested withNewServiceSpecObjectLike(ServiceSpec item){
            return new ServiceSpecObjectNestedImpl(item);
    }

    public A withResourceQuotaStatusObject(ResourceQuotaStatus resourceQuotaStatusObject){
            _visitables.remove(this.object);
            if (resourceQuotaStatusObject!=null){ this.object= new ResourceQuotaStatusBuilder(resourceQuotaStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ResourceQuotaStatusObjectNested withNewResourceQuotaStatusObject(){
            return new ResourceQuotaStatusObjectNestedImpl();
    }

    public WatchEventFluent.ResourceQuotaStatusObjectNested withNewResourceQuotaStatusObjectLike(ResourceQuotaStatus item){
            return new ResourceQuotaStatusObjectNestedImpl(item);
    }

    public A withClusterPipelineTaskTemplateObject(ClusterPipelineTaskTemplate clusterPipelineTaskTemplateObject){
            _visitables.remove(this.object);
            if (clusterPipelineTaskTemplateObject!=null){ this.object= new ClusterPipelineTaskTemplateBuilder(clusterPipelineTaskTemplateObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ClusterPipelineTaskTemplateObjectNested withNewClusterPipelineTaskTemplateObject(){
            return new ClusterPipelineTaskTemplateObjectNestedImpl();
    }

    public WatchEventFluent.ClusterPipelineTaskTemplateObjectNested withNewClusterPipelineTaskTemplateObjectLike(ClusterPipelineTaskTemplate item){
            return new ClusterPipelineTaskTemplateObjectNestedImpl(item);
    }

    public A withReplicaSetListObject(ReplicaSetList replicaSetListObject){
            _visitables.remove(this.object);
            if (replicaSetListObject!=null){ this.object= new ReplicaSetListBuilder(replicaSetListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ReplicaSetListObjectNested withNewReplicaSetListObject(){
            return new ReplicaSetListObjectNestedImpl();
    }

    public WatchEventFluent.ReplicaSetListObjectNested withNewReplicaSetListObjectLike(ReplicaSetList item){
            return new ReplicaSetListObjectNestedImpl(item);
    }

    public A withStatefulSetSpecObject(StatefulSetSpec statefulSetSpecObject){
            _visitables.remove(this.object);
            if (statefulSetSpecObject!=null){ this.object= new StatefulSetSpecBuilder(statefulSetSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatefulSetSpecObjectNested withNewStatefulSetSpecObject(){
            return new StatefulSetSpecObjectNestedImpl();
    }

    public WatchEventFluent.StatefulSetSpecObjectNested withNewStatefulSetSpecObjectLike(StatefulSetSpec item){
            return new StatefulSetSpecObjectNestedImpl(item);
    }

    public A withSecretProjectionObject(SecretProjection secretProjectionObject){
            _visitables.remove(this.object);
            if (secretProjectionObject!=null){ this.object= new SecretProjectionBuilder(secretProjectionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.SecretProjectionObjectNested withNewSecretProjectionObject(){
            return new SecretProjectionObjectNestedImpl();
    }

    public WatchEventFluent.SecretProjectionObjectNested withNewSecretProjectionObjectLike(SecretProjection item){
            return new SecretProjectionObjectNestedImpl(item);
    }

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

    public WatchEventFluent.DeploymentObjectNested withNewDeploymentObject(){
            return new DeploymentObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentObjectNested withNewDeploymentObjectLike(Deployment item){
            return new DeploymentObjectNestedImpl(item);
    }

    public A withJobConditionObject(JobCondition jobConditionObject){
            _visitables.remove(this.object);
            if (jobConditionObject!=null){ this.object= new JobConditionBuilder(jobConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.JobConditionObjectNested withNewJobConditionObject(){
            return new JobConditionObjectNestedImpl();
    }

    public WatchEventFluent.JobConditionObjectNested withNewJobConditionObjectLike(JobCondition item){
            return new JobConditionObjectNestedImpl(item);
    }

    public A withPersistentVolumeClaimVolumeSourceObject(PersistentVolumeClaimVolumeSource persistentVolumeClaimVolumeSourceObject){
            _visitables.remove(this.object);
            if (persistentVolumeClaimVolumeSourceObject!=null){ this.object= new PersistentVolumeClaimVolumeSourceBuilder(persistentVolumeClaimVolumeSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PersistentVolumeClaimVolumeSourceObjectNested withNewPersistentVolumeClaimVolumeSourceObject(){
            return new PersistentVolumeClaimVolumeSourceObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeClaimVolumeSourceObjectNested withNewPersistentVolumeClaimVolumeSourceObjectLike(PersistentVolumeClaimVolumeSource item){
            return new PersistentVolumeClaimVolumeSourceObjectNestedImpl(item);
    }

    public A withNewPersistentVolumeClaimVolumeSourceObject(String claimName,Boolean readOnly){
            return (A)withPersistentVolumeClaimVolumeSourceObject(new PersistentVolumeClaimVolumeSource(claimName, readOnly));
    }

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

    public WatchEventFluent.JenkinsObjectNested withNewJenkinsObject(){
            return new JenkinsObjectNestedImpl();
    }

    public WatchEventFluent.JenkinsObjectNested withNewJenkinsObjectLike(Jenkins item){
            return new JenkinsObjectNestedImpl(item);
    }

    public A withDeploymentStrategyObject(DeploymentStrategy deploymentStrategyObject){
            _visitables.remove(this.object);
            if (deploymentStrategyObject!=null){ this.object= new DeploymentStrategyBuilder(deploymentStrategyObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.DeploymentStrategyObjectNested withNewDeploymentStrategyObject(){
            return new DeploymentStrategyObjectNestedImpl();
    }

    public WatchEventFluent.DeploymentStrategyObjectNested withNewDeploymentStrategyObjectLike(DeploymentStrategy item){
            return new DeploymentStrategyObjectNestedImpl(item);
    }

    public A withContainerPortObject(ContainerPort containerPortObject){
            _visitables.remove(this.object);
            if (containerPortObject!=null){ this.object= new ContainerPortBuilder(containerPortObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ContainerPortObjectNested withNewContainerPortObject(){
            return new ContainerPortObjectNestedImpl();
    }

    public WatchEventFluent.ContainerPortObjectNested withNewContainerPortObjectLike(ContainerPort item){
            return new ContainerPortObjectNestedImpl(item);
    }

    public A withNewContainerPortObject(Integer containerPort,String hostIP,Integer hostPort,String name,String protocol){
            return (A)withContainerPortObject(new ContainerPort(containerPort, hostIP, hostPort, name, protocol));
    }

    public A withNodeAddressObject(NodeAddress nodeAddressObject){
            _visitables.remove(this.object);
            if (nodeAddressObject!=null){ this.object= new NodeAddressBuilder(nodeAddressObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeAddressObjectNested withNewNodeAddressObject(){
            return new NodeAddressObjectNestedImpl();
    }

    public WatchEventFluent.NodeAddressObjectNested withNewNodeAddressObjectLike(NodeAddress item){
            return new NodeAddressObjectNestedImpl(item);
    }

    public A withNewNodeAddressObject(String address,String type){
            return (A)withNodeAddressObject(new NodeAddress(address, type));
    }

    public A withPodTemplateListObject(PodTemplateList podTemplateListObject){
            _visitables.remove(this.object);
            if (podTemplateListObject!=null){ this.object= new PodTemplateListBuilder(podTemplateListObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PodTemplateListObjectNested withNewPodTemplateListObject(){
            return new PodTemplateListObjectNestedImpl();
    }

    public WatchEventFluent.PodTemplateListObjectNested withNewPodTemplateListObjectLike(PodTemplateList item){
            return new PodTemplateListObjectNestedImpl(item);
    }

    public A withPersistentVolumeStatusObject(PersistentVolumeStatus persistentVolumeStatusObject){
            _visitables.remove(this.object);
            if (persistentVolumeStatusObject!=null){ this.object= new PersistentVolumeStatusBuilder(persistentVolumeStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PersistentVolumeStatusObjectNested withNewPersistentVolumeStatusObject(){
            return new PersistentVolumeStatusObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeStatusObjectNested withNewPersistentVolumeStatusObjectLike(PersistentVolumeStatus item){
            return new PersistentVolumeStatusObjectNestedImpl(item);
    }

    public A withNewPersistentVolumeStatusObject(String message,String phase,String reason){
            return (A)withPersistentVolumeStatusObject(new PersistentVolumeStatus(message, phase, reason));
    }

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

    public WatchEventFluent.DaemonSetObjectNested withNewDaemonSetObject(){
            return new DaemonSetObjectNestedImpl();
    }

    public WatchEventFluent.DaemonSetObjectNested withNewDaemonSetObjectLike(DaemonSet item){
            return new DaemonSetObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PodDisruptionBudgetObjectNested withNewPodDisruptionBudgetObject(){
            return new PodDisruptionBudgetObjectNestedImpl();
    }

    public WatchEventFluent.PodDisruptionBudgetObjectNested withNewPodDisruptionBudgetObjectLike(PodDisruptionBudget item){
            return new PodDisruptionBudgetObjectNestedImpl(item);
    }

    public A withPipelineTaskArgumentActionObject(PipelineTaskArgumentAction pipelineTaskArgumentActionObject){
            _visitables.remove(this.object);
            if (pipelineTaskArgumentActionObject!=null){ this.object= new PipelineTaskArgumentActionBuilder(pipelineTaskArgumentActionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskArgumentActionObjectNested withNewPipelineTaskArgumentActionObject(){
            return new PipelineTaskArgumentActionObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskArgumentActionObjectNested withNewPipelineTaskArgumentActionObjectLike(PipelineTaskArgumentAction item){
            return new PipelineTaskArgumentActionObjectNestedImpl(item);
    }

    public A withProjectStatusObject(ProjectStatus projectStatusObject){
            _visitables.remove(this.object);
            if (projectStatusObject!=null){ this.object= new ProjectStatusBuilder(projectStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectStatusObjectNested withNewProjectStatusObject(){
            return new ProjectStatusObjectNestedImpl();
    }

    public WatchEventFluent.ProjectStatusObjectNested withNewProjectStatusObjectLike(ProjectStatus item){
            return new ProjectStatusObjectNestedImpl(item);
    }

    public A withPipelineSpecObject(PipelineSpec pipelineSpecObject){
            _visitables.remove(this.object);
            if (pipelineSpecObject!=null){ this.object= new PipelineSpecBuilder(pipelineSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineSpecObjectNested withNewPipelineSpecObject(){
            return new PipelineSpecObjectNestedImpl();
    }

    public WatchEventFluent.PipelineSpecObjectNested withNewPipelineSpecObjectLike(PipelineSpec item){
            return new PipelineSpecObjectNestedImpl(item);
    }

    public A withScaleStatusObject(ScaleStatus scaleStatusObject){
            _visitables.remove(this.object);
            if (scaleStatusObject!=null){ this.object= new ScaleStatusBuilder(scaleStatusObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ScaleStatusObjectNested withNewScaleStatusObject(){
            return new ScaleStatusObjectNestedImpl();
    }

    public WatchEventFluent.ScaleStatusObjectNested withNewScaleStatusObjectLike(ScaleStatus item){
            return new ScaleStatusObjectNestedImpl(item);
    }

    public A withProjectObject(Project projectObject){
            _visitables.remove(this.object);
            if (projectObject!=null){ this.object= new ProjectBuilder(projectObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ProjectObjectNested withNewProjectObject(){
            return new ProjectObjectNestedImpl();
    }

    public WatchEventFluent.ProjectObjectNested withNewProjectObjectLike(Project item){
            return new ProjectObjectNestedImpl(item);
    }

    public A withPipelineTaskArgumentObject(PipelineTaskArgument pipelineTaskArgumentObject){
            _visitables.remove(this.object);
            if (pipelineTaskArgumentObject!=null){ this.object= new PipelineTaskArgumentBuilder(pipelineTaskArgumentObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTaskArgumentObjectNested withNewPipelineTaskArgumentObject(){
            return new PipelineTaskArgumentObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTaskArgumentObjectNested withNewPipelineTaskArgumentObjectLike(PipelineTaskArgument item){
            return new PipelineTaskArgumentObjectNestedImpl(item);
    }

    public A withWatchEventObject(WatchEvent watchEventObject){
            _visitables.remove(this.object);
            if (watchEventObject!=null){ this.object= new WatchEventBuilder(watchEventObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.WatchEventObjectNested withNewWatchEventObject(){
            return new WatchEventObjectNestedImpl();
    }

    public WatchEventFluent.WatchEventObjectNested withNewWatchEventObjectLike(WatchEvent item){
            return new WatchEventObjectNestedImpl(item);
    }

    public A withConfigMapEnvSourceObject(ConfigMapEnvSource configMapEnvSourceObject){
            _visitables.remove(this.object);
            if (configMapEnvSourceObject!=null){ this.object= new ConfigMapEnvSourceBuilder(configMapEnvSourceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ConfigMapEnvSourceObjectNested withNewConfigMapEnvSourceObject(){
            return new ConfigMapEnvSourceObjectNestedImpl();
    }

    public WatchEventFluent.ConfigMapEnvSourceObjectNested withNewConfigMapEnvSourceObjectLike(ConfigMapEnvSource item){
            return new ConfigMapEnvSourceObjectNestedImpl(item);
    }

    public A withNewConfigMapEnvSourceObject(String name,Boolean optional){
            return (A)withConfigMapEnvSourceObject(new ConfigMapEnvSource(name, optional));
    }

    public A withHostAliasObject(HostAlias hostAliasObject){
            _visitables.remove(this.object);
            if (hostAliasObject!=null){ this.object= new HostAliasBuilder(hostAliasObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HostAliasObjectNested withNewHostAliasObject(){
            return new HostAliasObjectNestedImpl();
    }

    public WatchEventFluent.HostAliasObjectNested withNewHostAliasObjectLike(HostAlias item){
            return new HostAliasObjectNestedImpl(item);
    }

    public A withHTTPIngressRuleValueObject(HTTPIngressRuleValue hTTPIngressRuleValueObject){
            _visitables.remove(this.object);
            if (hTTPIngressRuleValueObject!=null){ this.object= new HTTPIngressRuleValueBuilder(hTTPIngressRuleValueObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.HTTPIngressRuleValueObjectNested withNewHTTPIngressRuleValueObject(){
            return new HTTPIngressRuleValueObjectNestedImpl();
    }

    public WatchEventFluent.HTTPIngressRuleValueObjectNested withNewHTTPIngressRuleValueObjectLike(HTTPIngressRuleValue item){
            return new HTTPIngressRuleValueObjectNestedImpl(item);
    }

    public A withEndpointPortObject(EndpointPort endpointPortObject){
            _visitables.remove(this.object);
            if (endpointPortObject!=null){ this.object= new EndpointPortBuilder(endpointPortObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.EndpointPortObjectNested withNewEndpointPortObject(){
            return new EndpointPortObjectNestedImpl();
    }

    public WatchEventFluent.EndpointPortObjectNested withNewEndpointPortObjectLike(EndpointPort item){
            return new EndpointPortObjectNestedImpl(item);
    }

    public A withNewEndpointPortObject(String name,Integer port,String protocol){
            return (A)withEndpointPortObject(new EndpointPort(name, port, protocol));
    }

    public A withStatusCauseObject(StatusCause statusCauseObject){
            _visitables.remove(this.object);
            if (statusCauseObject!=null){ this.object= new StatusCauseBuilder(statusCauseObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.StatusCauseObjectNested withNewStatusCauseObject(){
            return new StatusCauseObjectNestedImpl();
    }

    public WatchEventFluent.StatusCauseObjectNested withNewStatusCauseObjectLike(StatusCause item){
            return new StatusCauseObjectNestedImpl(item);
    }

    public A withNewStatusCauseObject(String field,String message,String reason){
            return (A)withStatusCauseObject(new StatusCause(field, message, reason));
    }

    public A withI18nNameObject(I18nName i18nNameObject){
            _visitables.remove(this.object);
            if (i18nNameObject!=null){ this.object= new I18nNameBuilder(i18nNameObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.I18nNameObjectNested withNewI18nNameObject(){
            return new I18nNameObjectNestedImpl();
    }

    public WatchEventFluent.I18nNameObjectNested withNewI18nNameObjectLike(I18nName item){
            return new I18nNameObjectNestedImpl(item);
    }

    public A withNewI18nNameObject(String en,String zhCN){
            return (A)withI18nNameObject(new I18nName(en, zhCN));
    }

    public A withPipelineRunLimitsObject(PipelineRunLimits pipelineRunLimitsObject){
            _visitables.remove(this.object);
            if (pipelineRunLimitsObject!=null){ this.object= new PipelineRunLimitsBuilder(pipelineRunLimitsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineRunLimitsObjectNested withNewPipelineRunLimitsObject(){
            return new PipelineRunLimitsObjectNestedImpl();
    }

    public WatchEventFluent.PipelineRunLimitsObjectNested withNewPipelineRunLimitsObjectLike(PipelineRunLimits item){
            return new PipelineRunLimitsObjectNestedImpl(item);
    }

    public A withNewPipelineRunLimitsObject(Long failureCount,Long successCount){
            return (A)withPipelineRunLimitsObject(new PipelineRunLimits(failureCount, successCount));
    }

    public A withNodeConditionObject(NodeCondition nodeConditionObject){
            _visitables.remove(this.object);
            if (nodeConditionObject!=null){ this.object= new NodeConditionBuilder(nodeConditionObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.NodeConditionObjectNested withNewNodeConditionObject(){
            return new NodeConditionObjectNestedImpl();
    }

    public WatchEventFluent.NodeConditionObjectNested withNewNodeConditionObjectLike(NodeCondition item){
            return new NodeConditionObjectNestedImpl(item);
    }

    public A withRollingUpdateDeploymentObject(RollingUpdateDeployment rollingUpdateDeploymentObject){
            _visitables.remove(this.object);
            if (rollingUpdateDeploymentObject!=null){ this.object= new RollingUpdateDeploymentBuilder(rollingUpdateDeploymentObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.RollingUpdateDeploymentObjectNested withNewRollingUpdateDeploymentObject(){
            return new RollingUpdateDeploymentObjectNestedImpl();
    }

    public WatchEventFluent.RollingUpdateDeploymentObjectNested withNewRollingUpdateDeploymentObjectLike(RollingUpdateDeployment item){
            return new RollingUpdateDeploymentObjectNestedImpl(item);
    }

    public A withPipelineStageObject(PipelineStage pipelineStageObject){
            _visitables.remove(this.object);
            if (pipelineStageObject!=null){ this.object= new PipelineStageBuilder(pipelineStageObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineStageObjectNested withNewPipelineStageObject(){
            return new PipelineStageObjectNestedImpl();
    }

    public WatchEventFluent.PipelineStageObjectNested withNewPipelineStageObjectLike(PipelineStage item){
            return new PipelineStageObjectNestedImpl(item);
    }

    public A withOriginCodeRepositoryObject(OriginCodeRepository originCodeRepositoryObject){
            _visitables.remove(this.object);
            if (originCodeRepositoryObject!=null){ this.object= new OriginCodeRepositoryBuilder(originCodeRepositoryObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.OriginCodeRepositoryObjectNested withNewOriginCodeRepositoryObject(){
            return new OriginCodeRepositoryObjectNestedImpl();
    }

    public WatchEventFluent.OriginCodeRepositoryObjectNested withNewOriginCodeRepositoryObjectLike(OriginCodeRepository item){
            return new OriginCodeRepositoryObjectNestedImpl(item);
    }

    public A withObjectReferenceObject(ObjectReference objectReferenceObject){
            _visitables.remove(this.object);
            if (objectReferenceObject!=null){ this.object= new ObjectReferenceBuilder(objectReferenceObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.ObjectReferenceObjectNested withNewObjectReferenceObject(){
            return new ObjectReferenceObjectNestedImpl();
    }

    public WatchEventFluent.ObjectReferenceObjectNested withNewObjectReferenceObjectLike(ObjectReference item){
            return new ObjectReferenceObjectNestedImpl(item);
    }

    public A withPipelineTemplateSpecObject(PipelineTemplateSpec pipelineTemplateSpecObject){
            _visitables.remove(this.object);
            if (pipelineTemplateSpecObject!=null){ this.object= new PipelineTemplateSpecBuilder(pipelineTemplateSpecObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineTemplateSpecObjectNested withNewPipelineTemplateSpecObject(){
            return new PipelineTemplateSpecObjectNestedImpl();
    }

    public WatchEventFluent.PipelineTemplateSpecObjectNested withNewPipelineTemplateSpecObjectLike(PipelineTemplateSpec item){
            return new PipelineTemplateSpecObjectNestedImpl(item);
    }

    public A withPipelineStrategyJenkinsObject(PipelineStrategyJenkins pipelineStrategyJenkinsObject){
            _visitables.remove(this.object);
            if (pipelineStrategyJenkinsObject!=null){ this.object= new PipelineStrategyJenkinsBuilder(pipelineStrategyJenkinsObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.PipelineStrategyJenkinsObjectNested withNewPipelineStrategyJenkinsObject(){
            return new PipelineStrategyJenkinsObjectNestedImpl();
    }

    public WatchEventFluent.PipelineStrategyJenkinsObjectNested withNewPipelineStrategyJenkinsObjectLike(PipelineStrategyJenkins item){
            return new PipelineStrategyJenkinsObjectNestedImpl(item);
    }

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

    public WatchEventFluent.PersistentVolumeObjectNested withNewPersistentVolumeObject(){
            return new PersistentVolumeObjectNestedImpl();
    }

    public WatchEventFluent.PersistentVolumeObjectNested withNewPersistentVolumeObjectLike(PersistentVolume item){
            return new PersistentVolumeObjectNestedImpl(item);
    }

    public A withCodeRepositoryObject(CodeRepository codeRepositoryObject){
            _visitables.remove(this.object);
            if (codeRepositoryObject!=null){ this.object= new CodeRepositoryBuilder(codeRepositoryObject); _visitables.add(this.object);} return (A) this;
    }

    public WatchEventFluent.CodeRepositoryObjectNested withNewCodeRepositoryObject(){
            return new CodeRepositoryObjectNestedImpl();
    }

    public WatchEventFluent.CodeRepositoryObjectNested withNewCodeRepositoryObjectLike(CodeRepository item){
            return new CodeRepositoryObjectNestedImpl(item);
    }

    public String getType(){
            return this.type;
    }

    public A withType(String type){
            this.type=type; return (A) this;
    }

    public Boolean hasType(){
            return this.type!=null;
    }

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


    public class RepositoryCommitObjectNestedImpl extends RepositoryCommitFluentImpl> implements WatchEventFluent.RepositoryCommitObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RepositoryCommitBuilder builder;
    
            RepositoryCommitObjectNestedImpl(RepositoryCommit item){
                    this.builder = new RepositoryCommitBuilder(this, item);
            }
            RepositoryCommitObjectNestedImpl(){
                    this.builder = new RepositoryCommitBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRepositoryCommitObject(builder.build());
    }
    public N endRepositoryCommitObject(){
            return and();
    }

}
    public class AffinityObjectNestedImpl extends AffinityFluentImpl> implements WatchEventFluent.AffinityObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AffinityBuilder builder;
    
            AffinityObjectNestedImpl(Affinity item){
                    this.builder = new AffinityBuilder(this, item);
            }
            AffinityObjectNestedImpl(){
                    this.builder = new AffinityBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAffinityObject(builder.build());
    }
    public N endAffinityObject(){
            return and();
    }

}
    public class NamedClusterObjectNestedImpl extends NamedClusterFluentImpl> implements WatchEventFluent.NamedClusterObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamedClusterBuilder builder;
    
            NamedClusterObjectNestedImpl(NamedCluster item){
                    this.builder = new NamedClusterBuilder(this, item);
            }
            NamedClusterObjectNestedImpl(){
                    this.builder = new NamedClusterBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamedClusterObject(builder.build());
    }
    public N endNamedClusterObject(){
            return and();
    }

}
    public class AWSElasticBlockStoreVolumeSourceObjectNestedImpl extends AWSElasticBlockStoreVolumeSourceFluentImpl> implements WatchEventFluent.AWSElasticBlockStoreVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AWSElasticBlockStoreVolumeSourceBuilder builder;
    
            AWSElasticBlockStoreVolumeSourceObjectNestedImpl(AWSElasticBlockStoreVolumeSource item){
                    this.builder = new AWSElasticBlockStoreVolumeSourceBuilder(this, item);
            }
            AWSElasticBlockStoreVolumeSourceObjectNestedImpl(){
                    this.builder = new AWSElasticBlockStoreVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAWSElasticBlockStoreVolumeSourceObject(builder.build());
    }
    public N endAWSElasticBlockStoreVolumeSourceObject(){
            return and();
    }

}
    public class ContextObjectNestedImpl extends ContextFluentImpl> implements WatchEventFluent.ContextObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContextBuilder builder;
    
            ContextObjectNestedImpl(Context item){
                    this.builder = new ContextBuilder(this, item);
            }
            ContextObjectNestedImpl(){
                    this.builder = new ContextBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContextObject(builder.build());
    }
    public N endContextObject(){
            return and();
    }

}
    public class ServicePortObjectNestedImpl extends ServicePortFluentImpl> implements WatchEventFluent.ServicePortObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServicePortBuilder builder;
    
            ServicePortObjectNestedImpl(ServicePort item){
                    this.builder = new ServicePortBuilder(this, item);
            }
            ServicePortObjectNestedImpl(){
                    this.builder = new ServicePortBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServicePortObject(builder.build());
    }
    public N endServicePortObject(){
            return and();
    }

}
    public class BindingObjectNestedImpl extends BindingFluentImpl> implements WatchEventFluent.BindingObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final BindingBuilder builder;
    
            BindingObjectNestedImpl(Binding item){
                    this.builder = new BindingBuilder(this, item);
            }
            BindingObjectNestedImpl(){
                    this.builder = new BindingBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withBindingObject(builder.build());
    }
    public N endBindingObject(){
            return and();
    }

}
    public class AuthInfoObjectNestedImpl extends AuthInfoFluentImpl> implements WatchEventFluent.AuthInfoObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AuthInfoBuilder builder;
    
            AuthInfoObjectNestedImpl(AuthInfo item){
                    this.builder = new AuthInfoBuilder(this, item);
            }
            AuthInfoObjectNestedImpl(){
                    this.builder = new AuthInfoBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAuthInfoObject(builder.build());
    }
    public N endAuthInfoObject(){
            return and();
    }

}
    public class IngressObjectNestedImpl extends IngressFluentImpl> implements WatchEventFluent.IngressObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressBuilder builder;
    
            IngressObjectNestedImpl(Ingress item){
                    this.builder = new IngressBuilder(this, item);
            }
            IngressObjectNestedImpl(){
                    this.builder = new IngressBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressObject(builder.build());
    }
    public N endIngressObject(){
            return and();
    }

}
    public class ClusterPipelineTaskTemplateListObjectNestedImpl extends ClusterPipelineTaskTemplateListFluentImpl> implements WatchEventFluent.ClusterPipelineTaskTemplateListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPipelineTaskTemplateListBuilder builder;
    
            ClusterPipelineTaskTemplateListObjectNestedImpl(ClusterPipelineTaskTemplateList item){
                    this.builder = new ClusterPipelineTaskTemplateListBuilder(this, item);
            }
            ClusterPipelineTaskTemplateListObjectNestedImpl(){
                    this.builder = new ClusterPipelineTaskTemplateListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withClusterPipelineTaskTemplateListObject(builder.build());
    }
    public N endClusterPipelineTaskTemplateListObject(){
            return and();
    }

}
    public class RollingUpdateStatefulSetStrategyObjectNestedImpl extends RollingUpdateStatefulSetStrategyFluentImpl> implements WatchEventFluent.RollingUpdateStatefulSetStrategyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RollingUpdateStatefulSetStrategyBuilder builder;
    
            RollingUpdateStatefulSetStrategyObjectNestedImpl(RollingUpdateStatefulSetStrategy item){
                    this.builder = new RollingUpdateStatefulSetStrategyBuilder(this, item);
            }
            RollingUpdateStatefulSetStrategyObjectNestedImpl(){
                    this.builder = new RollingUpdateStatefulSetStrategyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRollingUpdateStatefulSetStrategyObject(builder.build());
    }
    public N endRollingUpdateStatefulSetStrategyObject(){
            return and();
    }

}
    public class LocalSubjectAccessReviewObjectNestedImpl extends LocalSubjectAccessReviewFluentImpl> implements WatchEventFluent.LocalSubjectAccessReviewObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LocalSubjectAccessReviewBuilder builder;
    
            LocalSubjectAccessReviewObjectNestedImpl(LocalSubjectAccessReview item){
                    this.builder = new LocalSubjectAccessReviewBuilder(this, item);
            }
            LocalSubjectAccessReviewObjectNestedImpl(){
                    this.builder = new LocalSubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLocalSubjectAccessReviewObject(builder.build());
    }
    public N endLocalSubjectAccessReviewObject(){
            return and();
    }

}
    public class StatefulSetObjectNestedImpl extends StatefulSetFluentImpl> implements WatchEventFluent.StatefulSetObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetBuilder builder;
    
            StatefulSetObjectNestedImpl(StatefulSet item){
                    this.builder = new StatefulSetBuilder(this, item);
            }
            StatefulSetObjectNestedImpl(){
                    this.builder = new StatefulSetBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatefulSetObject(builder.build());
    }
    public N endStatefulSetObject(){
            return and();
    }

}
    public class PipelineTaskArgumentSchemaObjectNestedImpl extends PipelineTaskArgumentSchemaFluentImpl> implements WatchEventFluent.PipelineTaskArgumentSchemaObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentSchemaBuilder builder;
    
            PipelineTaskArgumentSchemaObjectNestedImpl(PipelineTaskArgumentSchema item){
                    this.builder = new PipelineTaskArgumentSchemaBuilder(this, item);
            }
            PipelineTaskArgumentSchemaObjectNestedImpl(){
                    this.builder = new PipelineTaskArgumentSchemaBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskArgumentSchemaObject(builder.build());
    }
    public N endPipelineTaskArgumentSchemaObject(){
            return and();
    }

}
    public class ContainerObjectNestedImpl extends ContainerFluentImpl> implements WatchEventFluent.ContainerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerBuilder builder;
    
            ContainerObjectNestedImpl(Container item){
                    this.builder = new ContainerBuilder(this, item);
            }
            ContainerObjectNestedImpl(){
                    this.builder = new ContainerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerObject(builder.build());
    }
    public N endContainerObject(){
            return and();
    }

}
    public class ResourceQuotaSpecObjectNestedImpl extends ResourceQuotaSpecFluentImpl> implements WatchEventFluent.ResourceQuotaSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaSpecBuilder builder;
    
            ResourceQuotaSpecObjectNestedImpl(ResourceQuotaSpec item){
                    this.builder = new ResourceQuotaSpecBuilder(this, item);
            }
            ResourceQuotaSpecObjectNestedImpl(){
                    this.builder = new ResourceQuotaSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceQuotaSpecObject(builder.build());
    }
    public N endResourceQuotaSpecObject(){
            return and();
    }

}
    public class PipelineTemplateTaskInstanceObjectNestedImpl extends PipelineTemplateTaskInstanceFluentImpl> implements WatchEventFluent.PipelineTemplateTaskInstanceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateTaskInstanceBuilder builder;
    
            PipelineTemplateTaskInstanceObjectNestedImpl(PipelineTemplateTaskInstance item){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this, item);
            }
            PipelineTemplateTaskInstanceObjectNestedImpl(){
                    this.builder = new PipelineTemplateTaskInstanceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateTaskInstanceObject(builder.build());
    }
    public N endPipelineTemplateTaskInstanceObject(){
            return and();
    }

}
    public class PipelineTemplateListObjectNestedImpl extends PipelineTemplateListFluentImpl> implements WatchEventFluent.PipelineTemplateListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateListBuilder builder;
    
            PipelineTemplateListObjectNestedImpl(PipelineTemplateList item){
                    this.builder = new PipelineTemplateListBuilder(this, item);
            }
            PipelineTemplateListObjectNestedImpl(){
                    this.builder = new PipelineTemplateListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateListObject(builder.build());
    }
    public N endPipelineTemplateListObject(){
            return and();
    }

}
    public class PipelineTaskOptionObjectNestedImpl extends PipelineTaskOptionFluentImpl> implements WatchEventFluent.PipelineTaskOptionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskOptionBuilder builder;
    
            PipelineTaskOptionObjectNestedImpl(PipelineTaskOption item){
                    this.builder = new PipelineTaskOptionBuilder(this, item);
            }
            PipelineTaskOptionObjectNestedImpl(){
                    this.builder = new PipelineTaskOptionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskOptionObject(builder.build());
    }
    public N endPipelineTaskOptionObject(){
            return and();
    }

}
    public class JobSpecObjectNestedImpl extends JobSpecFluentImpl> implements WatchEventFluent.JobSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobSpecBuilder builder;
    
            JobSpecObjectNestedImpl(JobSpec item){
                    this.builder = new JobSpecBuilder(this, item);
            }
            JobSpecObjectNestedImpl(){
                    this.builder = new JobSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJobSpecObject(builder.build());
    }
    public N endJobSpecObject(){
            return and();
    }

}
    public class SecretListObjectNestedImpl extends SecretListFluentImpl> implements WatchEventFluent.SecretListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretListBuilder builder;
    
            SecretListObjectNestedImpl(SecretList item){
                    this.builder = new SecretListBuilder(this, item);
            }
            SecretListObjectNestedImpl(){
                    this.builder = new SecretListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretListObject(builder.build());
    }
    public N endSecretListObject(){
            return and();
    }

}
    public class JenkinsListObjectNestedImpl extends JenkinsListFluentImpl> implements WatchEventFluent.JenkinsListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsListBuilder builder;
    
            JenkinsListObjectNestedImpl(JenkinsList item){
                    this.builder = new JenkinsListBuilder(this, item);
            }
            JenkinsListObjectNestedImpl(){
                    this.builder = new JenkinsListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsListObject(builder.build());
    }
    public N endJenkinsListObject(){
            return and();
    }

}
    public class LabelSelectorObjectNestedImpl extends LabelSelectorFluentImpl> implements WatchEventFluent.LabelSelectorObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LabelSelectorBuilder builder;
    
            LabelSelectorObjectNestedImpl(LabelSelector item){
                    this.builder = new LabelSelectorBuilder(this, item);
            }
            LabelSelectorObjectNestedImpl(){
                    this.builder = new LabelSelectorBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLabelSelectorObject(builder.build());
    }
    public N endLabelSelectorObject(){
            return and();
    }

}
    public class CronJobSpecObjectNestedImpl extends CronJobSpecFluentImpl> implements WatchEventFluent.CronJobSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobSpecBuilder builder;
    
            CronJobSpecObjectNestedImpl(CronJobSpec item){
                    this.builder = new CronJobSpecBuilder(this, item);
            }
            CronJobSpecObjectNestedImpl(){
                    this.builder = new CronJobSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCronJobSpecObject(builder.build());
    }
    public N endCronJobSpecObject(){
            return and();
    }

}
    public class DeleteOptionsObjectNestedImpl extends DeleteOptionsFluentImpl> implements WatchEventFluent.DeleteOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeleteOptionsBuilder builder;
    
            DeleteOptionsObjectNestedImpl(DeleteOptions item){
                    this.builder = new DeleteOptionsBuilder(this, item);
            }
            DeleteOptionsObjectNestedImpl(){
                    this.builder = new DeleteOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeleteOptionsObject(builder.build());
    }
    public N endDeleteOptionsObject(){
            return and();
    }

}
    public class PipelineTriggerObjectNestedImpl extends PipelineTriggerFluentImpl> implements WatchEventFluent.PipelineTriggerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTriggerBuilder builder;
    
            PipelineTriggerObjectNestedImpl(PipelineTrigger item){
                    this.builder = new PipelineTriggerBuilder(this, item);
            }
            PipelineTriggerObjectNestedImpl(){
                    this.builder = new PipelineTriggerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTriggerObject(builder.build());
    }
    public N endPipelineTriggerObject(){
            return and();
    }

}
    public class DeploymentRollbackObjectNestedImpl extends DeploymentRollbackFluentImpl> implements WatchEventFluent.DeploymentRollbackObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentRollbackBuilder builder;
    
            DeploymentRollbackObjectNestedImpl(DeploymentRollback item){
                    this.builder = new DeploymentRollbackBuilder(this, item);
            }
            DeploymentRollbackObjectNestedImpl(){
                    this.builder = new DeploymentRollbackBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentRollbackObject(builder.build());
    }
    public N endDeploymentRollbackObject(){
            return and();
    }

}
    public class SecretVolumeSourceObjectNestedImpl extends SecretVolumeSourceFluentImpl> implements WatchEventFluent.SecretVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretVolumeSourceBuilder builder;
    
            SecretVolumeSourceObjectNestedImpl(SecretVolumeSource item){
                    this.builder = new SecretVolumeSourceBuilder(this, item);
            }
            SecretVolumeSourceObjectNestedImpl(){
                    this.builder = new SecretVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretVolumeSourceObject(builder.build());
    }
    public N endSecretVolumeSourceObject(){
            return and();
    }

}
    public class DownwardAPIProjectionObjectNestedImpl extends DownwardAPIProjectionFluentImpl> implements WatchEventFluent.DownwardAPIProjectionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DownwardAPIProjectionBuilder builder;
    
            DownwardAPIProjectionObjectNestedImpl(DownwardAPIProjection item){
                    this.builder = new DownwardAPIProjectionBuilder(this, item);
            }
            DownwardAPIProjectionObjectNestedImpl(){
                    this.builder = new DownwardAPIProjectionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDownwardAPIProjectionObject(builder.build());
    }
    public N endDownwardAPIProjectionObject(){
            return and();
    }

}
    public class LoadBalancerIngressObjectNestedImpl extends LoadBalancerIngressFluentImpl> implements WatchEventFluent.LoadBalancerIngressObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LoadBalancerIngressBuilder builder;
    
            LoadBalancerIngressObjectNestedImpl(LoadBalancerIngress item){
                    this.builder = new LoadBalancerIngressBuilder(this, item);
            }
            LoadBalancerIngressObjectNestedImpl(){
                    this.builder = new LoadBalancerIngressBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLoadBalancerIngressObject(builder.build());
    }
    public N endLoadBalancerIngressObject(){
            return and();
    }

}
    public class CodeRepoBindingAccountObjectNestedImpl extends CodeRepoBindingAccountFluentImpl> implements WatchEventFluent.CodeRepoBindingAccountObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoBindingAccountBuilder builder;
    
            CodeRepoBindingAccountObjectNestedImpl(CodeRepoBindingAccount item){
                    this.builder = new CodeRepoBindingAccountBuilder(this, item);
            }
            CodeRepoBindingAccountObjectNestedImpl(){
                    this.builder = new CodeRepoBindingAccountBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoBindingAccountObject(builder.build());
    }
    public N endCodeRepoBindingAccountObject(){
            return and();
    }

}
    public class HorizontalPodAutoscalerSpecObjectNestedImpl extends HorizontalPodAutoscalerSpecFluentImpl> implements WatchEventFluent.HorizontalPodAutoscalerSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerSpecBuilder builder;
    
            HorizontalPodAutoscalerSpecObjectNestedImpl(HorizontalPodAutoscalerSpec item){
                    this.builder = new HorizontalPodAutoscalerSpecBuilder(this, item);
            }
            HorizontalPodAutoscalerSpecObjectNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHorizontalPodAutoscalerSpecObject(builder.build());
    }
    public N endHorizontalPodAutoscalerSpecObject(){
            return and();
    }

}
    public class ProjectNamespaceStatusObjectNestedImpl extends ProjectNamespaceStatusFluentImpl> implements WatchEventFluent.ProjectNamespaceStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectNamespaceStatusBuilder builder;
    
            ProjectNamespaceStatusObjectNestedImpl(ProjectNamespaceStatus item){
                    this.builder = new ProjectNamespaceStatusBuilder(this, item);
            }
            ProjectNamespaceStatusObjectNestedImpl(){
                    this.builder = new ProjectNamespaceStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectNamespaceStatusObject(builder.build());
    }
    public N endProjectNamespaceStatusObject(){
            return and();
    }

}
    public class KubernetesRunAsUserStrategyOptionsObjectNestedImpl extends KubernetesRunAsUserStrategyOptionsFluentImpl> implements WatchEventFluent.KubernetesRunAsUserStrategyOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final KubernetesRunAsUserStrategyOptionsBuilder builder;
    
            KubernetesRunAsUserStrategyOptionsObjectNestedImpl(KubernetesRunAsUserStrategyOptions item){
                    this.builder = new KubernetesRunAsUserStrategyOptionsBuilder(this, item);
            }
            KubernetesRunAsUserStrategyOptionsObjectNestedImpl(){
                    this.builder = new KubernetesRunAsUserStrategyOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withKubernetesRunAsUserStrategyOptionsObject(builder.build());
    }
    public N endKubernetesRunAsUserStrategyOptionsObject(){
            return and();
    }

}
    public class StatusDetailsObjectNestedImpl extends StatusDetailsFluentImpl> implements WatchEventFluent.StatusDetailsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatusDetailsBuilder builder;
    
            StatusDetailsObjectNestedImpl(StatusDetails item){
                    this.builder = new StatusDetailsBuilder(this, item);
            }
            StatusDetailsObjectNestedImpl(){
                    this.builder = new StatusDetailsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatusDetailsObject(builder.build());
    }
    public N endStatusDetailsObject(){
            return and();
    }

}
    public class PipelineTaskApproveObjectNestedImpl extends PipelineTaskApproveFluentImpl> implements WatchEventFluent.PipelineTaskApproveObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskApproveBuilder builder;
    
            PipelineTaskApproveObjectNestedImpl(PipelineTaskApprove item){
                    this.builder = new PipelineTaskApproveBuilder(this, item);
            }
            PipelineTaskApproveObjectNestedImpl(){
                    this.builder = new PipelineTaskApproveBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskApproveObject(builder.build());
    }
    public N endPipelineTaskApproveObject(){
            return and();
    }

}
    public class PodSecurityPolicyObjectNestedImpl extends PodSecurityPolicyFluentImpl> implements WatchEventFluent.PodSecurityPolicyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyBuilder builder;
    
            PodSecurityPolicyObjectNestedImpl(PodSecurityPolicy item){
                    this.builder = new PodSecurityPolicyBuilder(this, item);
            }
            PodSecurityPolicyObjectNestedImpl(){
                    this.builder = new PodSecurityPolicyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodSecurityPolicyObject(builder.build());
    }
    public N endPodSecurityPolicyObject(){
            return and();
    }

}
    public class WeightedPodAffinityTermObjectNestedImpl extends WeightedPodAffinityTermFluentImpl> implements WatchEventFluent.WeightedPodAffinityTermObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final WeightedPodAffinityTermBuilder builder;
    
            WeightedPodAffinityTermObjectNestedImpl(WeightedPodAffinityTerm item){
                    this.builder = new WeightedPodAffinityTermBuilder(this, item);
            }
            WeightedPodAffinityTermObjectNestedImpl(){
                    this.builder = new WeightedPodAffinityTermBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withWeightedPodAffinityTermObject(builder.build());
    }
    public N endWeightedPodAffinityTermObject(){
            return and();
    }

}
    public class PipelineObjectNestedImpl extends PipelineFluentImpl> implements WatchEventFluent.PipelineObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineBuilder builder;
    
            PipelineObjectNestedImpl(Pipeline item){
                    this.builder = new PipelineBuilder(this, item);
            }
            PipelineObjectNestedImpl(){
                    this.builder = new PipelineBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineObject(builder.build());
    }
    public N endPipelineObject(){
            return and();
    }

}
    public class NodeListObjectNestedImpl extends NodeListFluentImpl> implements WatchEventFluent.NodeListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeListBuilder builder;
    
            NodeListObjectNestedImpl(NodeList item){
                    this.builder = new NodeListBuilder(this, item);
            }
            NodeListObjectNestedImpl(){
                    this.builder = new NodeListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeListObject(builder.build());
    }
    public N endNodeListObject(){
            return and();
    }

}
    public class CinderVolumeSourceObjectNestedImpl extends CinderVolumeSourceFluentImpl> implements WatchEventFluent.CinderVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CinderVolumeSourceBuilder builder;
    
            CinderVolumeSourceObjectNestedImpl(CinderVolumeSource item){
                    this.builder = new CinderVolumeSourceBuilder(this, item);
            }
            CinderVolumeSourceObjectNestedImpl(){
                    this.builder = new CinderVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCinderVolumeSourceObject(builder.build());
    }
    public N endCinderVolumeSourceObject(){
            return and();
    }

}
    public class CustomResourceDefinitionStatusObjectNestedImpl extends CustomResourceDefinitionStatusFluentImpl> implements WatchEventFluent.CustomResourceDefinitionStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionStatusBuilder builder;
    
            CustomResourceDefinitionStatusObjectNestedImpl(CustomResourceDefinitionStatus item){
                    this.builder = new CustomResourceDefinitionStatusBuilder(this, item);
            }
            CustomResourceDefinitionStatusObjectNestedImpl(){
                    this.builder = new CustomResourceDefinitionStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCustomResourceDefinitionStatusObject(builder.build());
    }
    public N endCustomResourceDefinitionStatusObject(){
            return and();
    }

}
    public class NetworkPolicySpecObjectNestedImpl extends NetworkPolicySpecFluentImpl> implements WatchEventFluent.NetworkPolicySpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicySpecBuilder builder;
    
            NetworkPolicySpecObjectNestedImpl(NetworkPolicySpec item){
                    this.builder = new NetworkPolicySpecBuilder(this, item);
            }
            NetworkPolicySpecObjectNestedImpl(){
                    this.builder = new NetworkPolicySpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNetworkPolicySpecObject(builder.build());
    }
    public N endNetworkPolicySpecObject(){
            return and();
    }

}
    public class LocalVolumeSourceObjectNestedImpl extends LocalVolumeSourceFluentImpl> implements WatchEventFluent.LocalVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LocalVolumeSourceBuilder builder;
    
            LocalVolumeSourceObjectNestedImpl(LocalVolumeSource item){
                    this.builder = new LocalVolumeSourceBuilder(this, item);
            }
            LocalVolumeSourceObjectNestedImpl(){
                    this.builder = new LocalVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLocalVolumeSourceObject(builder.build());
    }
    public N endLocalVolumeSourceObject(){
            return and();
    }

}
    public class ResourceQuotaObjectNestedImpl extends ResourceQuotaFluentImpl> implements WatchEventFluent.ResourceQuotaObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaBuilder builder;
    
            ResourceQuotaObjectNestedImpl(ResourceQuota item){
                    this.builder = new ResourceQuotaBuilder(this, item);
            }
            ResourceQuotaObjectNestedImpl(){
                    this.builder = new ResourceQuotaBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceQuotaObject(builder.build());
    }
    public N endResourceQuotaObject(){
            return and();
    }

}
    public class PodListObjectNestedImpl extends PodListFluentImpl> implements WatchEventFluent.PodListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodListBuilder builder;
    
            PodListObjectNestedImpl(PodList item){
                    this.builder = new PodListBuilder(this, item);
            }
            PodListObjectNestedImpl(){
                    this.builder = new PodListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodListObject(builder.build());
    }
    public N endPodListObject(){
            return and();
    }

}
    public class UserInfoObjectNestedImpl extends UserInfoFluentImpl> implements WatchEventFluent.UserInfoObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final UserInfoBuilder builder;
    
            UserInfoObjectNestedImpl(UserInfo item){
                    this.builder = new UserInfoBuilder(this, item);
            }
            UserInfoObjectNestedImpl(){
                    this.builder = new UserInfoBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withUserInfoObject(builder.build());
    }
    public N endUserInfoObject(){
            return and();
    }

}
    public class PipelineSourceSvnObjectNestedImpl extends PipelineSourceSvnFluentImpl> implements WatchEventFluent.PipelineSourceSvnObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineSourceSvnBuilder builder;
    
            PipelineSourceSvnObjectNestedImpl(PipelineSourceSvn item){
                    this.builder = new PipelineSourceSvnBuilder(this, item);
            }
            PipelineSourceSvnObjectNestedImpl(){
                    this.builder = new PipelineSourceSvnBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineSourceSvnObject(builder.build());
    }
    public N endPipelineSourceSvnObject(){
            return and();
    }

}
    public class CustomResourceDefinitionSpecObjectNestedImpl extends CustomResourceDefinitionSpecFluentImpl> implements WatchEventFluent.CustomResourceDefinitionSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionSpecBuilder builder;
    
            CustomResourceDefinitionSpecObjectNestedImpl(CustomResourceDefinitionSpec item){
                    this.builder = new CustomResourceDefinitionSpecBuilder(this, item);
            }
            CustomResourceDefinitionSpecObjectNestedImpl(){
                    this.builder = new CustomResourceDefinitionSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCustomResourceDefinitionSpecObject(builder.build());
    }
    public N endCustomResourceDefinitionSpecObject(){
            return and();
    }

}
    public class CodeRepositoryStatusObjectNestedImpl extends CodeRepositoryStatusFluentImpl> implements WatchEventFluent.CodeRepositoryStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryStatusBuilder builder;
    
            CodeRepositoryStatusObjectNestedImpl(CodeRepositoryStatus item){
                    this.builder = new CodeRepositoryStatusBuilder(this, item);
            }
            CodeRepositoryStatusObjectNestedImpl(){
                    this.builder = new CodeRepositoryStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositoryStatusObject(builder.build());
    }
    public N endCodeRepositoryStatusObject(){
            return and();
    }

}
    public class AzureFileVolumeSourceObjectNestedImpl extends AzureFileVolumeSourceFluentImpl> implements WatchEventFluent.AzureFileVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AzureFileVolumeSourceBuilder builder;
    
            AzureFileVolumeSourceObjectNestedImpl(AzureFileVolumeSource item){
                    this.builder = new AzureFileVolumeSourceBuilder(this, item);
            }
            AzureFileVolumeSourceObjectNestedImpl(){
                    this.builder = new AzureFileVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAzureFileVolumeSourceObject(builder.build());
    }
    public N endAzureFileVolumeSourceObject(){
            return and();
    }

}
    public class CodeRepoServiceSpecObjectNestedImpl extends CodeRepoServiceSpecFluentImpl> implements WatchEventFluent.CodeRepoServiceSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoServiceSpecBuilder builder;
    
            CodeRepoServiceSpecObjectNestedImpl(CodeRepoServiceSpec item){
                    this.builder = new CodeRepoServiceSpecBuilder(this, item);
            }
            CodeRepoServiceSpecObjectNestedImpl(){
                    this.builder = new CodeRepoServiceSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoServiceSpecObject(builder.build());
    }
    public N endCodeRepoServiceSpecObject(){
            return and();
    }

}
    public class ServiceAccountObjectNestedImpl extends ServiceAccountFluentImpl> implements WatchEventFluent.ServiceAccountObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountBuilder builder;
    
            ServiceAccountObjectNestedImpl(ServiceAccount item){
                    this.builder = new ServiceAccountBuilder(this, item);
            }
            ServiceAccountObjectNestedImpl(){
                    this.builder = new ServiceAccountBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServiceAccountObject(builder.build());
    }
    public N endServiceAccountObject(){
            return and();
    }

}
    public class CodeRepoBindingSpecObjectNestedImpl extends CodeRepoBindingSpecFluentImpl> implements WatchEventFluent.CodeRepoBindingSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoBindingSpecBuilder builder;
    
            CodeRepoBindingSpecObjectNestedImpl(CodeRepoBindingSpec item){
                    this.builder = new CodeRepoBindingSpecBuilder(this, item);
            }
            CodeRepoBindingSpecObjectNestedImpl(){
                    this.builder = new CodeRepoBindingSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoBindingSpecObject(builder.build());
    }
    public N endCodeRepoBindingSpecObject(){
            return and();
    }

}
    public class StorageOSPersistentVolumeSourceObjectNestedImpl extends StorageOSPersistentVolumeSourceFluentImpl> implements WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageOSPersistentVolumeSourceBuilder builder;
    
            StorageOSPersistentVolumeSourceObjectNestedImpl(StorageOSPersistentVolumeSource item){
                    this.builder = new StorageOSPersistentVolumeSourceBuilder(this, item);
            }
            StorageOSPersistentVolumeSourceObjectNestedImpl(){
                    this.builder = new StorageOSPersistentVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStorageOSPersistentVolumeSourceObject(builder.build());
    }
    public N endStorageOSPersistentVolumeSourceObject(){
            return and();
    }

}
    public class LimitRangeSpecObjectNestedImpl extends LimitRangeSpecFluentImpl> implements WatchEventFluent.LimitRangeSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeSpecBuilder builder;
    
            LimitRangeSpecObjectNestedImpl(LimitRangeSpec item){
                    this.builder = new LimitRangeSpecBuilder(this, item);
            }
            LimitRangeSpecObjectNestedImpl(){
                    this.builder = new LimitRangeSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLimitRangeSpecObject(builder.build());
    }
    public N endLimitRangeSpecObject(){
            return and();
    }

}
    public class PipelineStageInstanceObjectNestedImpl extends PipelineStageInstanceFluentImpl> implements WatchEventFluent.PipelineStageInstanceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineStageInstanceBuilder builder;
    
            PipelineStageInstanceObjectNestedImpl(PipelineStageInstance item){
                    this.builder = new PipelineStageInstanceBuilder(this, item);
            }
            PipelineStageInstanceObjectNestedImpl(){
                    this.builder = new PipelineStageInstanceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineStageInstanceObject(builder.build());
    }
    public N endPipelineStageInstanceObject(){
            return and();
    }

}
    public class ProjectListObjectNestedImpl extends ProjectListFluentImpl> implements WatchEventFluent.ProjectListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectListBuilder builder;
    
            ProjectListObjectNestedImpl(ProjectList item){
                    this.builder = new ProjectListBuilder(this, item);
            }
            ProjectListObjectNestedImpl(){
                    this.builder = new ProjectListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectListObject(builder.build());
    }
    public N endProjectListObject(){
            return and();
    }

}
    public class ConfigMapObjectNestedImpl extends ConfigMapFluentImpl> implements WatchEventFluent.ConfigMapObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapBuilder builder;
    
            ConfigMapObjectNestedImpl(ConfigMap item){
                    this.builder = new ConfigMapBuilder(this, item);
            }
            ConfigMapObjectNestedImpl(){
                    this.builder = new ConfigMapBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigMapObject(builder.build());
    }
    public N endConfigMapObject(){
            return and();
    }

}
    public class PipelineCauseObjectNestedImpl extends PipelineCauseFluentImpl> implements WatchEventFluent.PipelineCauseObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineCauseBuilder builder;
    
            PipelineCauseObjectNestedImpl(PipelineCause item){
                    this.builder = new PipelineCauseBuilder(this, item);
            }
            PipelineCauseObjectNestedImpl(){
                    this.builder = new PipelineCauseBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineCauseObject(builder.build());
    }
    public N endPipelineCauseObject(){
            return and();
    }

}
    public class VolumeObjectNestedImpl extends VolumeFluentImpl> implements WatchEventFluent.VolumeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final VolumeBuilder builder;
    
            VolumeObjectNestedImpl(Volume item){
                    this.builder = new VolumeBuilder(this, item);
            }
            VolumeObjectNestedImpl(){
                    this.builder = new VolumeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withVolumeObject(builder.build());
    }
    public N endVolumeObject(){
            return and();
    }

}
    public class FSGroupStrategyOptionsObjectNestedImpl extends FSGroupStrategyOptionsFluentImpl> implements WatchEventFluent.FSGroupStrategyOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final FSGroupStrategyOptionsBuilder builder;
    
            FSGroupStrategyOptionsObjectNestedImpl(FSGroupStrategyOptions item){
                    this.builder = new FSGroupStrategyOptionsBuilder(this, item);
            }
            FSGroupStrategyOptionsObjectNestedImpl(){
                    this.builder = new FSGroupStrategyOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withFSGroupStrategyOptionsObject(builder.build());
    }
    public N endFSGroupStrategyOptionsObject(){
            return and();
    }

}
    public class PipelineStatusJenkinsObjectNestedImpl extends PipelineStatusJenkinsFluentImpl> implements WatchEventFluent.PipelineStatusJenkinsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineStatusJenkinsBuilder builder;
    
            PipelineStatusJenkinsObjectNestedImpl(PipelineStatusJenkins item){
                    this.builder = new PipelineStatusJenkinsBuilder(this, item);
            }
            PipelineStatusJenkinsObjectNestedImpl(){
                    this.builder = new PipelineStatusJenkinsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineStatusJenkinsObject(builder.build());
    }
    public N endPipelineStatusJenkinsObject(){
            return and();
    }

}
    public class JenkinsBindingObjectNestedImpl extends JenkinsBindingFluentImpl> implements WatchEventFluent.JenkinsBindingObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingBuilder builder;
    
            JenkinsBindingObjectNestedImpl(JenkinsBinding item){
                    this.builder = new JenkinsBindingBuilder(this, item);
            }
            JenkinsBindingObjectNestedImpl(){
                    this.builder = new JenkinsBindingBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsBindingObject(builder.build());
    }
    public N endJenkinsBindingObject(){
            return and();
    }

}
    public class PipelineTemplateObjectNestedImpl extends PipelineTemplateFluentImpl> implements WatchEventFluent.PipelineTemplateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateBuilder builder;
    
            PipelineTemplateObjectNestedImpl(PipelineTemplate item){
                    this.builder = new PipelineTemplateBuilder(this, item);
            }
            PipelineTemplateObjectNestedImpl(){
                    this.builder = new PipelineTemplateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateObject(builder.build());
    }
    public N endPipelineTemplateObject(){
            return and();
    }

}
    public class NodeAffinityObjectNestedImpl extends NodeAffinityFluentImpl> implements WatchEventFluent.NodeAffinityObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeAffinityBuilder builder;
    
            NodeAffinityObjectNestedImpl(NodeAffinity item){
                    this.builder = new NodeAffinityBuilder(this, item);
            }
            NodeAffinityObjectNestedImpl(){
                    this.builder = new NodeAffinityBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeAffinityObject(builder.build());
    }
    public N endNodeAffinityObject(){
            return and();
    }

}
    public class PipelineConfigStatusObjectNestedImpl extends PipelineConfigStatusFluentImpl> implements WatchEventFluent.PipelineConfigStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigStatusBuilder builder;
    
            PipelineConfigStatusObjectNestedImpl(PipelineConfigStatus item){
                    this.builder = new PipelineConfigStatusBuilder(this, item);
            }
            PipelineConfigStatusObjectNestedImpl(){
                    this.builder = new PipelineConfigStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineConfigStatusObject(builder.build());
    }
    public N endPipelineConfigStatusObject(){
            return and();
    }

}
    public class ConfigMapListObjectNestedImpl extends ConfigMapListFluentImpl> implements WatchEventFluent.ConfigMapListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapListBuilder builder;
    
            ConfigMapListObjectNestedImpl(ConfigMapList item){
                    this.builder = new ConfigMapListBuilder(this, item);
            }
            ConfigMapListObjectNestedImpl(){
                    this.builder = new ConfigMapListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigMapListObject(builder.build());
    }
    public N endConfigMapListObject(){
            return and();
    }

}
    public class PipelineTriggeScheduleObjectNestedImpl extends PipelineTriggeScheduleFluentImpl> implements WatchEventFluent.PipelineTriggeScheduleObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTriggeScheduleBuilder builder;
    
            PipelineTriggeScheduleObjectNestedImpl(PipelineTriggeSchedule item){
                    this.builder = new PipelineTriggeScheduleBuilder(this, item);
            }
            PipelineTriggeScheduleObjectNestedImpl(){
                    this.builder = new PipelineTriggeScheduleBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTriggeScheduleObject(builder.build());
    }
    public N endPipelineTriggeScheduleObject(){
            return and();
    }

}
    public class PipelineTaskTemplateListObjectNestedImpl extends PipelineTaskTemplateListFluentImpl> implements WatchEventFluent.PipelineTaskTemplateListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskTemplateListBuilder builder;
    
            PipelineTaskTemplateListObjectNestedImpl(PipelineTaskTemplateList item){
                    this.builder = new PipelineTaskTemplateListBuilder(this, item);
            }
            PipelineTaskTemplateListObjectNestedImpl(){
                    this.builder = new PipelineTaskTemplateListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskTemplateListObject(builder.build());
    }
    public N endPipelineTaskTemplateListObject(){
            return and();
    }

}
    public class DaemonSetStatusObjectNestedImpl extends DaemonSetStatusFluentImpl> implements WatchEventFluent.DaemonSetStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetStatusBuilder builder;
    
            DaemonSetStatusObjectNestedImpl(DaemonSetStatus item){
                    this.builder = new DaemonSetStatusBuilder(this, item);
            }
            DaemonSetStatusObjectNestedImpl(){
                    this.builder = new DaemonSetStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDaemonSetStatusObject(builder.build());
    }
    public N endDaemonSetStatusObject(){
            return and();
    }

}
    public class BaseKubernetesListObjectNestedImpl extends BaseKubernetesListFluentImpl> implements WatchEventFluent.BaseKubernetesListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final BaseKubernetesListBuilder builder;
    
            BaseKubernetesListObjectNestedImpl(BaseKubernetesList item){
                    this.builder = new BaseKubernetesListBuilder(this, item);
            }
            BaseKubernetesListObjectNestedImpl(){
                    this.builder = new BaseKubernetesListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withBaseKubernetesListObject(builder.build());
    }
    public N endBaseKubernetesListObject(){
            return and();
    }

}
    public class InitializerObjectNestedImpl extends InitializerFluentImpl> implements WatchEventFluent.InitializerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final InitializerBuilder builder;
    
            InitializerObjectNestedImpl(Initializer item){
                    this.builder = new InitializerBuilder(this, item);
            }
            InitializerObjectNestedImpl(){
                    this.builder = new InitializerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withInitializerObject(builder.build());
    }
    public N endInitializerObject(){
            return and();
    }

}
    public class StatusObjectNestedImpl extends StatusFluentImpl> implements WatchEventFluent.StatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatusBuilder builder;
    
            StatusObjectNestedImpl(Status item){
                    this.builder = new StatusBuilder(this, item);
            }
            StatusObjectNestedImpl(){
                    this.builder = new StatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatusObject(builder.build());
    }
    public N endStatusObject(){
            return and();
    }

}
    public class CronJobObjectNestedImpl extends CronJobFluentImpl> implements WatchEventFluent.CronJobObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobBuilder builder;
    
            CronJobObjectNestedImpl(CronJob item){
                    this.builder = new CronJobBuilder(this, item);
            }
            CronJobObjectNestedImpl(){
                    this.builder = new CronJobBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCronJobObject(builder.build());
    }
    public N endCronJobObject(){
            return and();
    }

}
    public class ListMetaObjectNestedImpl extends ListMetaFluentImpl> implements WatchEventFluent.ListMetaObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ListMetaBuilder builder;
    
            ListMetaObjectNestedImpl(ListMeta item){
                    this.builder = new ListMetaBuilder(this, item);
            }
            ListMetaObjectNestedImpl(){
                    this.builder = new ListMetaBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withListMetaObject(builder.build());
    }
    public N endListMetaObject(){
            return and();
    }

}
    public class ComponentStatusListObjectNestedImpl extends ComponentStatusListFluentImpl> implements WatchEventFluent.ComponentStatusListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentStatusListBuilder builder;
    
            ComponentStatusListObjectNestedImpl(ComponentStatusList item){
                    this.builder = new ComponentStatusListBuilder(this, item);
            }
            ComponentStatusListObjectNestedImpl(){
                    this.builder = new ComponentStatusListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withComponentStatusListObject(builder.build());
    }
    public N endComponentStatusListObject(){
            return and();
    }

}
    public class JenkinsBindingListObjectNestedImpl extends JenkinsBindingListFluentImpl> implements WatchEventFluent.JenkinsBindingListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingListBuilder builder;
    
            JenkinsBindingListObjectNestedImpl(JenkinsBindingList item){
                    this.builder = new JenkinsBindingListBuilder(this, item);
            }
            JenkinsBindingListObjectNestedImpl(){
                    this.builder = new JenkinsBindingListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsBindingListObject(builder.build());
    }
    public N endJenkinsBindingListObject(){
            return and();
    }

}
    public class BindingConditionObjectNestedImpl extends BindingConditionFluentImpl> implements WatchEventFluent.BindingConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final BindingConditionBuilder builder;
    
            BindingConditionObjectNestedImpl(BindingCondition item){
                    this.builder = new BindingConditionBuilder(this, item);
            }
            BindingConditionObjectNestedImpl(){
                    this.builder = new BindingConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withBindingConditionObject(builder.build());
    }
    public N endBindingConditionObject(){
            return and();
    }

}
    public class NodeStatusObjectNestedImpl extends NodeStatusFluentImpl> implements WatchEventFluent.NodeStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeStatusBuilder builder;
    
            NodeStatusObjectNestedImpl(NodeStatus item){
                    this.builder = new NodeStatusBuilder(this, item);
            }
            NodeStatusObjectNestedImpl(){
                    this.builder = new NodeStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeStatusObject(builder.build());
    }
    public N endNodeStatusObject(){
            return and();
    }

}
    public class GlobalParameterObjectNestedImpl extends GlobalParameterFluentImpl> implements WatchEventFluent.GlobalParameterObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final GlobalParameterBuilder builder;
    
            GlobalParameterObjectNestedImpl(GlobalParameter item){
                    this.builder = new GlobalParameterBuilder(this, item);
            }
            GlobalParameterObjectNestedImpl(){
                    this.builder = new GlobalParameterBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withGlobalParameterObject(builder.build());
    }
    public N endGlobalParameterObject(){
            return and();
    }

}
    public class TokenReviewSpecObjectNestedImpl extends TokenReviewSpecFluentImpl> implements WatchEventFluent.TokenReviewSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewSpecBuilder builder;
    
            TokenReviewSpecObjectNestedImpl(TokenReviewSpec item){
                    this.builder = new TokenReviewSpecBuilder(this, item);
            }
            TokenReviewSpecObjectNestedImpl(){
                    this.builder = new TokenReviewSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withTokenReviewSpecObject(builder.build());
    }
    public N endTokenReviewSpecObject(){
            return and();
    }

}
    public class PipelineEnvironmentObjectNestedImpl extends PipelineEnvironmentFluentImpl> implements WatchEventFluent.PipelineEnvironmentObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineEnvironmentBuilder builder;
    
            PipelineEnvironmentObjectNestedImpl(PipelineEnvironment item){
                    this.builder = new PipelineEnvironmentBuilder(this, item);
            }
            PipelineEnvironmentObjectNestedImpl(){
                    this.builder = new PipelineEnvironmentBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineEnvironmentObject(builder.build());
    }
    public N endPipelineEnvironmentObject(){
            return and();
    }

}
    public class EventListObjectNestedImpl extends EventListFluentImpl> implements WatchEventFluent.EventListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventListBuilder builder;
    
            EventListObjectNestedImpl(EventList item){
                    this.builder = new EventListBuilder(this, item);
            }
            EventListObjectNestedImpl(){
                    this.builder = new EventListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEventListObject(builder.build());
    }
    public N endEventListObject(){
            return and();
    }

}
    public class VolumeMountObjectNestedImpl extends VolumeMountFluentImpl> implements WatchEventFluent.VolumeMountObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final VolumeMountBuilder builder;
    
            VolumeMountObjectNestedImpl(VolumeMount item){
                    this.builder = new VolumeMountBuilder(this, item);
            }
            VolumeMountObjectNestedImpl(){
                    this.builder = new VolumeMountBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withVolumeMountObject(builder.build());
    }
    public N endVolumeMountObject(){
            return and();
    }

}
    public class SubjectAccessReviewObjectNestedImpl extends SubjectAccessReviewFluentImpl> implements WatchEventFluent.SubjectAccessReviewObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SubjectAccessReviewBuilder builder;
    
            SubjectAccessReviewObjectNestedImpl(SubjectAccessReview item){
                    this.builder = new SubjectAccessReviewBuilder(this, item);
            }
            SubjectAccessReviewObjectNestedImpl(){
                    this.builder = new SubjectAccessReviewBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSubjectAccessReviewObject(builder.build());
    }
    public N endSubjectAccessReviewObject(){
            return and();
    }

}
    public class SELinuxOptionsObjectNestedImpl extends SELinuxOptionsFluentImpl> implements WatchEventFluent.SELinuxOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SELinuxOptionsBuilder builder;
    
            SELinuxOptionsObjectNestedImpl(SELinuxOptions item){
                    this.builder = new SELinuxOptionsBuilder(this, item);
            }
            SELinuxOptionsObjectNestedImpl(){
                    this.builder = new SELinuxOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSELinuxOptionsObject(builder.build());
    }
    public N endSELinuxOptionsObject(){
            return and();
    }

}
    public class DeploymentSpecObjectNestedImpl extends DeploymentSpecFluentImpl> implements WatchEventFluent.DeploymentSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentSpecBuilder builder;
    
            DeploymentSpecObjectNestedImpl(DeploymentSpec item){
                    this.builder = new DeploymentSpecBuilder(this, item);
            }
            DeploymentSpecObjectNestedImpl(){
                    this.builder = new DeploymentSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentSpecObject(builder.build());
    }
    public N endDeploymentSpecObject(){
            return and();
    }

}
    public class PersistentVolumeClaimListObjectNestedImpl extends PersistentVolumeClaimListFluentImpl> implements WatchEventFluent.PersistentVolumeClaimListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimListBuilder builder;
    
            PersistentVolumeClaimListObjectNestedImpl(PersistentVolumeClaimList item){
                    this.builder = new PersistentVolumeClaimListBuilder(this, item);
            }
            PersistentVolumeClaimListObjectNestedImpl(){
                    this.builder = new PersistentVolumeClaimListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeClaimListObject(builder.build());
    }
    public N endPersistentVolumeClaimListObject(){
            return and();
    }

}
    public class PodTemplateObjectNestedImpl extends PodTemplateFluentImpl> implements WatchEventFluent.PodTemplateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateBuilder builder;
    
            PodTemplateObjectNestedImpl(PodTemplate item){
                    this.builder = new PodTemplateBuilder(this, item);
            }
            PodTemplateObjectNestedImpl(){
                    this.builder = new PodTemplateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodTemplateObject(builder.build());
    }
    public N endPodTemplateObject(){
            return and();
    }

}
    public class FCVolumeSourceObjectNestedImpl extends FCVolumeSourceFluentImpl> implements WatchEventFluent.FCVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final FCVolumeSourceBuilder builder;
    
            FCVolumeSourceObjectNestedImpl(FCVolumeSource item){
                    this.builder = new FCVolumeSourceBuilder(this, item);
            }
            FCVolumeSourceObjectNestedImpl(){
                    this.builder = new FCVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withFCVolumeSourceObject(builder.build());
    }
    public N endFCVolumeSourceObject(){
            return and();
    }

}
    public class PipelineStatusObjectNestedImpl extends PipelineStatusFluentImpl> implements WatchEventFluent.PipelineStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineStatusBuilder builder;
    
            PipelineStatusObjectNestedImpl(PipelineStatus item){
                    this.builder = new PipelineStatusBuilder(this, item);
            }
            PipelineStatusObjectNestedImpl(){
                    this.builder = new PipelineStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineStatusObject(builder.build());
    }
    public N endPipelineStatusObject(){
            return and();
    }

}
    public class PipelineTemplateArgumentValueObjectNestedImpl extends PipelineTemplateArgumentValueFluentImpl> implements WatchEventFluent.PipelineTemplateArgumentValueObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateArgumentValueBuilder builder;
    
            PipelineTemplateArgumentValueObjectNestedImpl(PipelineTemplateArgumentValue item){
                    this.builder = new PipelineTemplateArgumentValueBuilder(this, item);
            }
            PipelineTemplateArgumentValueObjectNestedImpl(){
                    this.builder = new PipelineTemplateArgumentValueBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateArgumentValueObject(builder.build());
    }
    public N endPipelineTemplateArgumentValueObject(){
            return and();
    }

}
    public class DaemonSetSpecObjectNestedImpl extends DaemonSetSpecFluentImpl> implements WatchEventFluent.DaemonSetSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetSpecBuilder builder;
    
            DaemonSetSpecObjectNestedImpl(DaemonSetSpec item){
                    this.builder = new DaemonSetSpecBuilder(this, item);
            }
            DaemonSetSpecObjectNestedImpl(){
                    this.builder = new DaemonSetSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDaemonSetSpecObject(builder.build());
    }
    public N endDaemonSetSpecObject(){
            return and();
    }

}
    public class PipelineStrategyObjectNestedImpl extends PipelineStrategyFluentImpl> implements WatchEventFluent.PipelineStrategyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineStrategyBuilder builder;
    
            PipelineStrategyObjectNestedImpl(PipelineStrategy item){
                    this.builder = new PipelineStrategyBuilder(this, item);
            }
            PipelineStrategyObjectNestedImpl(){
                    this.builder = new PipelineStrategyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineStrategyObject(builder.build());
    }
    public N endPipelineStrategyObject(){
            return and();
    }

}
    public class ConditionObjectNestedImpl extends ConditionFluentImpl> implements WatchEventFluent.ConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConditionBuilder builder;
    
            ConditionObjectNestedImpl(Condition item){
                    this.builder = new ConditionBuilder(this, item);
            }
            ConditionObjectNestedImpl(){
                    this.builder = new ConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConditionObject(builder.build());
    }
    public N endConditionObject(){
            return and();
    }

}
    public class ContainerStateWaitingObjectNestedImpl extends ContainerStateWaitingFluentImpl> implements WatchEventFluent.ContainerStateWaitingObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerStateWaitingBuilder builder;
    
            ContainerStateWaitingObjectNestedImpl(ContainerStateWaiting item){
                    this.builder = new ContainerStateWaitingBuilder(this, item);
            }
            ContainerStateWaitingObjectNestedImpl(){
                    this.builder = new ContainerStateWaitingBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerStateWaitingObject(builder.build());
    }
    public N endContainerStateWaitingObject(){
            return and();
    }

}
    public class TokenReviewObjectNestedImpl extends TokenReviewFluentImpl> implements WatchEventFluent.TokenReviewObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewBuilder builder;
    
            TokenReviewObjectNestedImpl(TokenReview item){
                    this.builder = new TokenReviewBuilder(this, item);
            }
            TokenReviewObjectNestedImpl(){
                    this.builder = new TokenReviewBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withTokenReviewObject(builder.build());
    }
    public N endTokenReviewObject(){
            return and();
    }

}
    public class ScaleSpecObjectNestedImpl extends ScaleSpecFluentImpl> implements WatchEventFluent.ScaleSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleSpecBuilder builder;
    
            ScaleSpecObjectNestedImpl(ScaleSpec item){
                    this.builder = new ScaleSpecBuilder(this, item);
            }
            ScaleSpecObjectNestedImpl(){
                    this.builder = new ScaleSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withScaleSpecObject(builder.build());
    }
    public N endScaleSpecObject(){
            return and();
    }

}
    public class CodeRepoBindingListObjectNestedImpl extends CodeRepoBindingListFluentImpl> implements WatchEventFluent.CodeRepoBindingListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoBindingListBuilder builder;
    
            CodeRepoBindingListObjectNestedImpl(CodeRepoBindingList item){
                    this.builder = new CodeRepoBindingListBuilder(this, item);
            }
            CodeRepoBindingListObjectNestedImpl(){
                    this.builder = new CodeRepoBindingListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoBindingListObject(builder.build());
    }
    public N endCodeRepoBindingListObject(){
            return and();
    }

}
    public class NetworkPolicyPeerObjectNestedImpl extends NetworkPolicyPeerFluentImpl> implements WatchEventFluent.NetworkPolicyPeerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyPeerBuilder builder;
    
            NetworkPolicyPeerObjectNestedImpl(NetworkPolicyPeer item){
                    this.builder = new NetworkPolicyPeerBuilder(this, item);
            }
            NetworkPolicyPeerObjectNestedImpl(){
                    this.builder = new NetworkPolicyPeerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNetworkPolicyPeerObject(builder.build());
    }
    public N endNetworkPolicyPeerObject(){
            return and();
    }

}
    public class PreferencesObjectNestedImpl extends PreferencesFluentImpl> implements WatchEventFluent.PreferencesObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PreferencesBuilder builder;
    
            PreferencesObjectNestedImpl(Preferences item){
                    this.builder = new PreferencesBuilder(this, item);
            }
            PreferencesObjectNestedImpl(){
                    this.builder = new PreferencesBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPreferencesObject(builder.build());
    }
    public N endPreferencesObject(){
            return and();
    }

}
    public class MultiBranchBehavioursObjectNestedImpl extends MultiBranchBehavioursFluentImpl> implements WatchEventFluent.MultiBranchBehavioursObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final MultiBranchBehavioursBuilder builder;
    
            MultiBranchBehavioursObjectNestedImpl(MultiBranchBehaviours item){
                    this.builder = new MultiBranchBehavioursBuilder(this, item);
            }
            MultiBranchBehavioursObjectNestedImpl(){
                    this.builder = new MultiBranchBehavioursBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withMultiBranchBehavioursObject(builder.build());
    }
    public N endMultiBranchBehavioursObject(){
            return and();
    }

}
    public class NodeDaemonEndpointsObjectNestedImpl extends NodeDaemonEndpointsFluentImpl> implements WatchEventFluent.NodeDaemonEndpointsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeDaemonEndpointsBuilder builder;
    
            NodeDaemonEndpointsObjectNestedImpl(NodeDaemonEndpoints item){
                    this.builder = new NodeDaemonEndpointsBuilder(this, item);
            }
            NodeDaemonEndpointsObjectNestedImpl(){
                    this.builder = new NodeDaemonEndpointsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeDaemonEndpointsObject(builder.build());
    }
    public N endNodeDaemonEndpointsObject(){
            return and();
    }

}
    public class PersistentVolumeListObjectNestedImpl extends PersistentVolumeListFluentImpl> implements WatchEventFluent.PersistentVolumeListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeListBuilder builder;
    
            PersistentVolumeListObjectNestedImpl(PersistentVolumeList item){
                    this.builder = new PersistentVolumeListBuilder(this, item);
            }
            PersistentVolumeListObjectNestedImpl(){
                    this.builder = new PersistentVolumeListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeListObject(builder.build());
    }
    public N endPersistentVolumeListObject(){
            return and();
    }

}
    public class LimitRangeItemObjectNestedImpl extends LimitRangeItemFluentImpl> implements WatchEventFluent.LimitRangeItemObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeItemBuilder builder;
    
            LimitRangeItemObjectNestedImpl(LimitRangeItem item){
                    this.builder = new LimitRangeItemBuilder(this, item);
            }
            LimitRangeItemObjectNestedImpl(){
                    this.builder = new LimitRangeItemBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLimitRangeItemObject(builder.build());
    }
    public N endLimitRangeItemObject(){
            return and();
    }

}
    public class DaemonSetUpdateStrategyObjectNestedImpl extends DaemonSetUpdateStrategyFluentImpl> implements WatchEventFluent.DaemonSetUpdateStrategyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetUpdateStrategyBuilder builder;
    
            DaemonSetUpdateStrategyObjectNestedImpl(DaemonSetUpdateStrategy item){
                    this.builder = new DaemonSetUpdateStrategyBuilder(this, item);
            }
            DaemonSetUpdateStrategyObjectNestedImpl(){
                    this.builder = new DaemonSetUpdateStrategyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDaemonSetUpdateStrategyObject(builder.build());
    }
    public N endDaemonSetUpdateStrategyObject(){
            return and();
    }

}
    public class CustomResourceDefinitionObjectNestedImpl extends CustomResourceDefinitionFluentImpl> implements WatchEventFluent.CustomResourceDefinitionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionBuilder builder;
    
            CustomResourceDefinitionObjectNestedImpl(CustomResourceDefinition item){
                    this.builder = new CustomResourceDefinitionBuilder(this, item);
            }
            CustomResourceDefinitionObjectNestedImpl(){
                    this.builder = new CustomResourceDefinitionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCustomResourceDefinitionObject(builder.build());
    }
    public N endCustomResourceDefinitionObject(){
            return and();
    }

}
    public class IngressListObjectNestedImpl extends IngressListFluentImpl> implements WatchEventFluent.IngressListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressListBuilder builder;
    
            IngressListObjectNestedImpl(IngressList item){
                    this.builder = new IngressListBuilder(this, item);
            }
            IngressListObjectNestedImpl(){
                    this.builder = new IngressListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressListObject(builder.build());
    }
    public N endIngressListObject(){
            return and();
    }

}
    public class FlexVolumeSourceObjectNestedImpl extends FlexVolumeSourceFluentImpl> implements WatchEventFluent.FlexVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final FlexVolumeSourceBuilder builder;
    
            FlexVolumeSourceObjectNestedImpl(FlexVolumeSource item){
                    this.builder = new FlexVolumeSourceBuilder(this, item);
            }
            FlexVolumeSourceObjectNestedImpl(){
                    this.builder = new FlexVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withFlexVolumeSourceObject(builder.build());
    }
    public N endFlexVolumeSourceObject(){
            return and();
    }

}
    public class JenkinsAgentObjectNestedImpl extends JenkinsAgentFluentImpl> implements WatchEventFluent.JenkinsAgentObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsAgentBuilder builder;
    
            JenkinsAgentObjectNestedImpl(JenkinsAgent item){
                    this.builder = new JenkinsAgentBuilder(this, item);
            }
            JenkinsAgentObjectNestedImpl(){
                    this.builder = new JenkinsAgentBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsAgentObject(builder.build());
    }
    public N endJenkinsAgentObject(){
            return and();
    }

}
    public class DeploymentConditionObjectNestedImpl extends DeploymentConditionFluentImpl> implements WatchEventFluent.DeploymentConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentConditionBuilder builder;
    
            DeploymentConditionObjectNestedImpl(DeploymentCondition item){
                    this.builder = new DeploymentConditionBuilder(this, item);
            }
            DeploymentConditionObjectNestedImpl(){
                    this.builder = new DeploymentConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentConditionObject(builder.build());
    }
    public N endDeploymentConditionObject(){
            return and();
    }

}
    public class ConfigObjectNestedImpl extends ConfigFluentImpl> implements WatchEventFluent.ConfigObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigBuilder builder;
    
            ConfigObjectNestedImpl(Config item){
                    this.builder = new ConfigBuilder(this, item);
            }
            ConfigObjectNestedImpl(){
                    this.builder = new ConfigBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigObject(builder.build());
    }
    public N endConfigObject(){
            return and();
    }

}
    public class PipelineParameterObjectNestedImpl extends PipelineParameterFluentImpl> implements WatchEventFluent.PipelineParameterObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineParameterBuilder builder;
    
            PipelineParameterObjectNestedImpl(PipelineParameter item){
                    this.builder = new PipelineParameterBuilder(this, item);
            }
            PipelineParameterObjectNestedImpl(){
                    this.builder = new PipelineParameterBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineParameterObject(builder.build());
    }
    public N endPipelineParameterObject(){
            return and();
    }

}
    public class NamespaceListObjectNestedImpl extends NamespaceListFluentImpl> implements WatchEventFluent.NamespaceListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceListBuilder builder;
    
            NamespaceListObjectNestedImpl(NamespaceList item){
                    this.builder = new NamespaceListBuilder(this, item);
            }
            NamespaceListObjectNestedImpl(){
                    this.builder = new NamespaceListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamespaceListObject(builder.build());
    }
    public N endNamespaceListObject(){
            return and();
    }

}
    public class PodDisruptionBudgetStatusObjectNestedImpl extends PodDisruptionBudgetStatusFluentImpl> implements WatchEventFluent.PodDisruptionBudgetStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetStatusBuilder builder;
    
            PodDisruptionBudgetStatusObjectNestedImpl(PodDisruptionBudgetStatus item){
                    this.builder = new PodDisruptionBudgetStatusBuilder(this, item);
            }
            PodDisruptionBudgetStatusObjectNestedImpl(){
                    this.builder = new PodDisruptionBudgetStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodDisruptionBudgetStatusObject(builder.build());
    }
    public N endPodDisruptionBudgetStatusObject(){
            return and();
    }

}
    public class CodeRepositorySpecObjectNestedImpl extends CodeRepositorySpecFluentImpl> implements WatchEventFluent.CodeRepositorySpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositorySpecBuilder builder;
    
            CodeRepositorySpecObjectNestedImpl(CodeRepositorySpec item){
                    this.builder = new CodeRepositorySpecBuilder(this, item);
            }
            CodeRepositorySpecObjectNestedImpl(){
                    this.builder = new CodeRepositorySpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositorySpecObject(builder.build());
    }
    public N endCodeRepositorySpecObject(){
            return and();
    }

}
    public class PodDisruptionBudgetListObjectNestedImpl extends PodDisruptionBudgetListFluentImpl> implements WatchEventFluent.PodDisruptionBudgetListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetListBuilder builder;
    
            PodDisruptionBudgetListObjectNestedImpl(PodDisruptionBudgetList item){
                    this.builder = new PodDisruptionBudgetListBuilder(this, item);
            }
            PodDisruptionBudgetListObjectNestedImpl(){
                    this.builder = new PodDisruptionBudgetListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodDisruptionBudgetListObject(builder.build());
    }
    public N endPodDisruptionBudgetListObject(){
            return and();
    }

}
    public class DeploymentStatusObjectNestedImpl extends DeploymentStatusFluentImpl> implements WatchEventFluent.DeploymentStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentStatusBuilder builder;
    
            DeploymentStatusObjectNestedImpl(DeploymentStatus item){
                    this.builder = new DeploymentStatusBuilder(this, item);
            }
            DeploymentStatusObjectNestedImpl(){
                    this.builder = new DeploymentStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentStatusObject(builder.build());
    }
    public N endDeploymentStatusObject(){
            return and();
    }

}
    public class StorageClassObjectNestedImpl extends StorageClassFluentImpl> implements WatchEventFluent.StorageClassObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassBuilder builder;
    
            StorageClassObjectNestedImpl(StorageClass item){
                    this.builder = new StorageClassBuilder(this, item);
            }
            StorageClassObjectNestedImpl(){
                    this.builder = new StorageClassBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStorageClassObject(builder.build());
    }
    public N endStorageClassObject(){
            return and();
    }

}
    public class UserAccountObjectNestedImpl extends UserAccountFluentImpl> implements WatchEventFluent.UserAccountObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final UserAccountBuilder builder;
    
            UserAccountObjectNestedImpl(UserAccount item){
                    this.builder = new UserAccountBuilder(this, item);
            }
            UserAccountObjectNestedImpl(){
                    this.builder = new UserAccountBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withUserAccountObject(builder.build());
    }
    public N endUserAccountObject(){
            return and();
    }

}
    public class QuobyteVolumeSourceObjectNestedImpl extends QuobyteVolumeSourceFluentImpl> implements WatchEventFluent.QuobyteVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final QuobyteVolumeSourceBuilder builder;
    
            QuobyteVolumeSourceObjectNestedImpl(QuobyteVolumeSource item){
                    this.builder = new QuobyteVolumeSourceBuilder(this, item);
            }
            QuobyteVolumeSourceObjectNestedImpl(){
                    this.builder = new QuobyteVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withQuobyteVolumeSourceObject(builder.build());
    }
    public N endQuobyteVolumeSourceObject(){
            return and();
    }

}
    public class MultiBranchOrphanObjectNestedImpl extends MultiBranchOrphanFluentImpl> implements WatchEventFluent.MultiBranchOrphanObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final MultiBranchOrphanBuilder builder;
    
            MultiBranchOrphanObjectNestedImpl(MultiBranchOrphan item){
                    this.builder = new MultiBranchOrphanBuilder(this, item);
            }
            MultiBranchOrphanObjectNestedImpl(){
                    this.builder = new MultiBranchOrphanBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withMultiBranchOrphanObject(builder.build());
    }
    public N endMultiBranchOrphanObject(){
            return and();
    }

}
    public class PreferredSchedulingTermObjectNestedImpl extends PreferredSchedulingTermFluentImpl> implements WatchEventFluent.PreferredSchedulingTermObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PreferredSchedulingTermBuilder builder;
    
            PreferredSchedulingTermObjectNestedImpl(PreferredSchedulingTerm item){
                    this.builder = new PreferredSchedulingTermBuilder(this, item);
            }
            PreferredSchedulingTermObjectNestedImpl(){
                    this.builder = new PreferredSchedulingTermBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPreferredSchedulingTermObject(builder.build());
    }
    public N endPreferredSchedulingTermObject(){
            return and();
    }

}
    public class HostPortRangeObjectNestedImpl extends HostPortRangeFluentImpl> implements WatchEventFluent.HostPortRangeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HostPortRangeBuilder builder;
    
            HostPortRangeObjectNestedImpl(HostPortRange item){
                    this.builder = new HostPortRangeBuilder(this, item);
            }
            HostPortRangeObjectNestedImpl(){
                    this.builder = new HostPortRangeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHostPortRangeObject(builder.build());
    }
    public N endHostPortRangeObject(){
            return and();
    }

}
    public class PodSecurityPolicyListObjectNestedImpl extends PodSecurityPolicyListFluentImpl> implements WatchEventFluent.PodSecurityPolicyListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicyListBuilder builder;
    
            PodSecurityPolicyListObjectNestedImpl(PodSecurityPolicyList item){
                    this.builder = new PodSecurityPolicyListBuilder(this, item);
            }
            PodSecurityPolicyListObjectNestedImpl(){
                    this.builder = new PodSecurityPolicyListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodSecurityPolicyListObject(builder.build());
    }
    public N endPodSecurityPolicyListObject(){
            return and();
    }

}
    public class ReplicationControllerSpecObjectNestedImpl extends ReplicationControllerSpecFluentImpl> implements WatchEventFluent.ReplicationControllerSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerSpecBuilder builder;
    
            ReplicationControllerSpecObjectNestedImpl(ReplicationControllerSpec item){
                    this.builder = new ReplicationControllerSpecBuilder(this, item);
            }
            ReplicationControllerSpecObjectNestedImpl(){
                    this.builder = new ReplicationControllerSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicationControllerSpecObject(builder.build());
    }
    public N endReplicationControllerSpecObject(){
            return and();
    }

}
    public class PipelineConfigListObjectNestedImpl extends PipelineConfigListFluentImpl> implements WatchEventFluent.PipelineConfigListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigListBuilder builder;
    
            PipelineConfigListObjectNestedImpl(PipelineConfigList item){
                    this.builder = new PipelineConfigListBuilder(this, item);
            }
            PipelineConfigListObjectNestedImpl(){
                    this.builder = new PipelineConfigListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineConfigListObject(builder.build());
    }
    public N endPipelineConfigListObject(){
            return and();
    }

}
    public class PipelineHookHTTPRequestObjectNestedImpl extends PipelineHookHTTPRequestFluentImpl> implements WatchEventFluent.PipelineHookHTTPRequestObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineHookHTTPRequestBuilder builder;
    
            PipelineHookHTTPRequestObjectNestedImpl(PipelineHookHTTPRequest item){
                    this.builder = new PipelineHookHTTPRequestBuilder(this, item);
            }
            PipelineHookHTTPRequestObjectNestedImpl(){
                    this.builder = new PipelineHookHTTPRequestBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineHookHTTPRequestObject(builder.build());
    }
    public N endPipelineHookHTTPRequestObject(){
            return and();
    }

}
    public class ResourceFieldSelectorObjectNestedImpl extends ResourceFieldSelectorFluentImpl> implements WatchEventFluent.ResourceFieldSelectorObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceFieldSelectorBuilder builder;
    
            ResourceFieldSelectorObjectNestedImpl(ResourceFieldSelector item){
                    this.builder = new ResourceFieldSelectorBuilder(this, item);
            }
            ResourceFieldSelectorObjectNestedImpl(){
                    this.builder = new ResourceFieldSelectorBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceFieldSelectorObject(builder.build());
    }
    public N endResourceFieldSelectorObject(){
            return and();
    }

}
    public class HostPathVolumeSourceObjectNestedImpl extends HostPathVolumeSourceFluentImpl> implements WatchEventFluent.HostPathVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HostPathVolumeSourceBuilder builder;
    
            HostPathVolumeSourceObjectNestedImpl(HostPathVolumeSource item){
                    this.builder = new HostPathVolumeSourceBuilder(this, item);
            }
            HostPathVolumeSourceObjectNestedImpl(){
                    this.builder = new HostPathVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHostPathVolumeSourceObject(builder.build());
    }
    public N endHostPathVolumeSourceObject(){
            return and();
    }

}
    public class SELinuxStrategyOptionsObjectNestedImpl extends SELinuxStrategyOptionsFluentImpl> implements WatchEventFluent.SELinuxStrategyOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SELinuxStrategyOptionsBuilder builder;
    
            SELinuxStrategyOptionsObjectNestedImpl(SELinuxStrategyOptions item){
                    this.builder = new SELinuxStrategyOptionsBuilder(this, item);
            }
            SELinuxStrategyOptionsObjectNestedImpl(){
                    this.builder = new SELinuxStrategyOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSELinuxStrategyOptionsObject(builder.build());
    }
    public N endSELinuxStrategyOptionsObject(){
            return and();
    }

}
    public class PipelineConfigTemplateObjectNestedImpl extends PipelineConfigTemplateFluentImpl> implements WatchEventFluent.PipelineConfigTemplateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigTemplateBuilder builder;
    
            PipelineConfigTemplateObjectNestedImpl(PipelineConfigTemplate item){
                    this.builder = new PipelineConfigTemplateBuilder(this, item);
            }
            PipelineConfigTemplateObjectNestedImpl(){
                    this.builder = new PipelineConfigTemplateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineConfigTemplateObject(builder.build());
    }
    public N endPipelineConfigTemplateObject(){
            return and();
    }

}
    public class ContainerStatusObjectNestedImpl extends ContainerStatusFluentImpl> implements WatchEventFluent.ContainerStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerStatusBuilder builder;
    
            ContainerStatusObjectNestedImpl(ContainerStatus item){
                    this.builder = new ContainerStatusBuilder(this, item);
            }
            ContainerStatusObjectNestedImpl(){
                    this.builder = new ContainerStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerStatusObject(builder.build());
    }
    public N endContainerStatusObject(){
            return and();
    }

}
    public class ExecActionObjectNestedImpl extends ExecActionFluentImpl> implements WatchEventFluent.ExecActionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ExecActionBuilder builder;
    
            ExecActionObjectNestedImpl(ExecAction item){
                    this.builder = new ExecActionBuilder(this, item);
            }
            ExecActionObjectNestedImpl(){
                    this.builder = new ExecActionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withExecActionObject(builder.build());
    }
    public N endExecActionObject(){
            return and();
    }

}
    public class PreconditionsObjectNestedImpl extends PreconditionsFluentImpl> implements WatchEventFluent.PreconditionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PreconditionsBuilder builder;
    
            PreconditionsObjectNestedImpl(Preconditions item){
                    this.builder = new PreconditionsBuilder(this, item);
            }
            PreconditionsObjectNestedImpl(){
                    this.builder = new PreconditionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPreconditionsObject(builder.build());
    }
    public N endPreconditionsObject(){
            return and();
    }

}
    public class OwnerInRepositoryObjectNestedImpl extends OwnerInRepositoryFluentImpl> implements WatchEventFluent.OwnerInRepositoryObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final OwnerInRepositoryBuilder builder;
    
            OwnerInRepositoryObjectNestedImpl(OwnerInRepository item){
                    this.builder = new OwnerInRepositoryBuilder(this, item);
            }
            OwnerInRepositoryObjectNestedImpl(){
                    this.builder = new OwnerInRepositoryBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withOwnerInRepositoryObject(builder.build());
    }
    public N endOwnerInRepositoryObject(){
            return and();
    }

}
    public class ClusterPipelineTemplateListObjectNestedImpl extends ClusterPipelineTemplateListFluentImpl> implements WatchEventFluent.ClusterPipelineTemplateListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPipelineTemplateListBuilder builder;
    
            ClusterPipelineTemplateListObjectNestedImpl(ClusterPipelineTemplateList item){
                    this.builder = new ClusterPipelineTemplateListBuilder(this, item);
            }
            ClusterPipelineTemplateListObjectNestedImpl(){
                    this.builder = new ClusterPipelineTemplateListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withClusterPipelineTemplateListObject(builder.build());
    }
    public N endClusterPipelineTemplateListObject(){
            return and();
    }

}
    public class IngressRuleObjectNestedImpl extends IngressRuleFluentImpl> implements WatchEventFluent.IngressRuleObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressRuleBuilder builder;
    
            IngressRuleObjectNestedImpl(IngressRule item){
                    this.builder = new IngressRuleBuilder(this, item);
            }
            IngressRuleObjectNestedImpl(){
                    this.builder = new IngressRuleBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressRuleObject(builder.build());
    }
    public N endIngressRuleObject(){
            return and();
    }

}
    public class StatefulSetStatusObjectNestedImpl extends StatefulSetStatusFluentImpl> implements WatchEventFluent.StatefulSetStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetStatusBuilder builder;
    
            StatefulSetStatusObjectNestedImpl(StatefulSetStatus item){
                    this.builder = new StatefulSetStatusBuilder(this, item);
            }
            StatefulSetStatusObjectNestedImpl(){
                    this.builder = new StatefulSetStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatefulSetStatusObject(builder.build());
    }
    public N endStatefulSetStatusObject(){
            return and();
    }

}
    public class NamespaceObjectNestedImpl extends NamespaceFluentImpl> implements WatchEventFluent.NamespaceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceBuilder builder;
    
            NamespaceObjectNestedImpl(Namespace item){
                    this.builder = new NamespaceBuilder(this, item);
            }
            NamespaceObjectNestedImpl(){
                    this.builder = new NamespaceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamespaceObject(builder.build());
    }
    public N endNamespaceObject(){
            return and();
    }

}
    public class NodeSelectorObjectNestedImpl extends NodeSelectorFluentImpl> implements WatchEventFluent.NodeSelectorObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeSelectorBuilder builder;
    
            NodeSelectorObjectNestedImpl(NodeSelector item){
                    this.builder = new NodeSelectorBuilder(this, item);
            }
            NodeSelectorObjectNestedImpl(){
                    this.builder = new NodeSelectorBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeSelectorObject(builder.build());
    }
    public N endNodeSelectorObject(){
            return and();
    }

}
    public class JenkinsfilePreviewOptionsObjectNestedImpl extends JenkinsfilePreviewOptionsFluentImpl> implements WatchEventFluent.JenkinsfilePreviewOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsfilePreviewOptionsBuilder builder;
    
            JenkinsfilePreviewOptionsObjectNestedImpl(JenkinsfilePreviewOptions item){
                    this.builder = new JenkinsfilePreviewOptionsBuilder(this, item);
            }
            JenkinsfilePreviewOptionsObjectNestedImpl(){
                    this.builder = new JenkinsfilePreviewOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsfilePreviewOptionsObject(builder.build());
    }
    public N endJenkinsfilePreviewOptionsObject(){
            return and();
    }

}
    public class PipelineListObjectNestedImpl extends PipelineListFluentImpl> implements WatchEventFluent.PipelineListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineListBuilder builder;
    
            PipelineListObjectNestedImpl(PipelineList item){
                    this.builder = new PipelineListBuilder(this, item);
            }
            PipelineListObjectNestedImpl(){
                    this.builder = new PipelineListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineListObject(builder.build());
    }
    public N endPipelineListObject(){
            return and();
    }

}
    public class HTTPGetActionObjectNestedImpl extends HTTPGetActionFluentImpl> implements WatchEventFluent.HTTPGetActionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HTTPGetActionBuilder builder;
    
            HTTPGetActionObjectNestedImpl(HTTPGetAction item){
                    this.builder = new HTTPGetActionBuilder(this, item);
            }
            HTTPGetActionObjectNestedImpl(){
                    this.builder = new HTTPGetActionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHTTPGetActionObject(builder.build());
    }
    public N endHTTPGetActionObject(){
            return and();
    }

}
    public class EndpointsListObjectNestedImpl extends EndpointsListFluentImpl> implements WatchEventFluent.EndpointsListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsListBuilder builder;
    
            EndpointsListObjectNestedImpl(EndpointsList item){
                    this.builder = new EndpointsListBuilder(this, item);
            }
            EndpointsListObjectNestedImpl(){
                    this.builder = new EndpointsListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEndpointsListObject(builder.build());
    }
    public N endEndpointsListObject(){
            return and();
    }

}
    public class JenkinsfilePreviewObjectNestedImpl extends JenkinsfilePreviewFluentImpl> implements WatchEventFluent.JenkinsfilePreviewObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsfilePreviewBuilder builder;
    
            JenkinsfilePreviewObjectNestedImpl(JenkinsfilePreview item){
                    this.builder = new JenkinsfilePreviewBuilder(this, item);
            }
            JenkinsfilePreviewObjectNestedImpl(){
                    this.builder = new JenkinsfilePreviewBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsfilePreviewObject(builder.build());
    }
    public N endJenkinsfilePreviewObject(){
            return and();
    }

}
    public class ReplicationControllerStatusObjectNestedImpl extends ReplicationControllerStatusFluentImpl> implements WatchEventFluent.ReplicationControllerStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerStatusBuilder builder;
    
            ReplicationControllerStatusObjectNestedImpl(ReplicationControllerStatus item){
                    this.builder = new ReplicationControllerStatusBuilder(this, item);
            }
            ReplicationControllerStatusObjectNestedImpl(){
                    this.builder = new ReplicationControllerStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicationControllerStatusObject(builder.build());
    }
    public N endReplicationControllerStatusObject(){
            return and();
    }

}
    public class PipelineConfigObjectNestedImpl extends PipelineConfigFluentImpl> implements WatchEventFluent.PipelineConfigObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigBuilder builder;
    
            PipelineConfigObjectNestedImpl(PipelineConfig item){
                    this.builder = new PipelineConfigBuilder(this, item);
            }
            PipelineConfigObjectNestedImpl(){
                    this.builder = new PipelineConfigBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineConfigObject(builder.build());
    }
    public N endPipelineConfigObject(){
            return and();
    }

}
    public class TolerationObjectNestedImpl extends TolerationFluentImpl> implements WatchEventFluent.TolerationObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final TolerationBuilder builder;
    
            TolerationObjectNestedImpl(Toleration item){
                    this.builder = new TolerationBuilder(this, item);
            }
            TolerationObjectNestedImpl(){
                    this.builder = new TolerationBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withTolerationObject(builder.build());
    }
    public N endTolerationObject(){
            return and();
    }

}
    public class CodeRepoServiceObjectNestedImpl extends CodeRepoServiceFluentImpl> implements WatchEventFluent.CodeRepoServiceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoServiceBuilder builder;
    
            CodeRepoServiceObjectNestedImpl(CodeRepoService item){
                    this.builder = new CodeRepoServiceBuilder(this, item);
            }
            CodeRepoServiceObjectNestedImpl(){
                    this.builder = new CodeRepoServiceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoServiceObject(builder.build());
    }
    public N endCodeRepoServiceObject(){
            return and();
    }

}
    public class PipelineTaskArgumentValidationObjectNestedImpl extends PipelineTaskArgumentValidationFluentImpl> implements WatchEventFluent.PipelineTaskArgumentValidationObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentValidationBuilder builder;
    
            PipelineTaskArgumentValidationObjectNestedImpl(PipelineTaskArgumentValidation item){
                    this.builder = new PipelineTaskArgumentValidationBuilder(this, item);
            }
            PipelineTaskArgumentValidationObjectNestedImpl(){
                    this.builder = new PipelineTaskArgumentValidationBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskArgumentValidationObject(builder.build());
    }
    public N endPipelineTaskArgumentValidationObject(){
            return and();
    }

}
    public class AttachedVolumeObjectNestedImpl extends AttachedVolumeFluentImpl> implements WatchEventFluent.AttachedVolumeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AttachedVolumeBuilder builder;
    
            AttachedVolumeObjectNestedImpl(AttachedVolume item){
                    this.builder = new AttachedVolumeBuilder(this, item);
            }
            AttachedVolumeObjectNestedImpl(){
                    this.builder = new AttachedVolumeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAttachedVolumeObject(builder.build());
    }
    public N endAttachedVolumeObject(){
            return and();
    }

}
    public class StatefulSetListObjectNestedImpl extends StatefulSetListFluentImpl> implements WatchEventFluent.StatefulSetListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetListBuilder builder;
    
            StatefulSetListObjectNestedImpl(StatefulSetList item){
                    this.builder = new StatefulSetListBuilder(this, item);
            }
            StatefulSetListObjectNestedImpl(){
                    this.builder = new StatefulSetListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatefulSetListObject(builder.build());
    }
    public N endStatefulSetListObject(){
            return and();
    }

}
    public class JenkinsStatusObjectNestedImpl extends JenkinsStatusFluentImpl> implements WatchEventFluent.JenkinsStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsStatusBuilder builder;
    
            JenkinsStatusObjectNestedImpl(JenkinsStatus item){
                    this.builder = new JenkinsStatusBuilder(this, item);
            }
            JenkinsStatusObjectNestedImpl(){
                    this.builder = new JenkinsStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsStatusObject(builder.build());
    }
    public N endJenkinsStatusObject(){
            return and();
    }

}
    public class PipelineTriggerCodeChangeObjectNestedImpl extends PipelineTriggerCodeChangeFluentImpl> implements WatchEventFluent.PipelineTriggerCodeChangeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTriggerCodeChangeBuilder builder;
    
            PipelineTriggerCodeChangeObjectNestedImpl(PipelineTriggerCodeChange item){
                    this.builder = new PipelineTriggerCodeChangeBuilder(this, item);
            }
            PipelineTriggerCodeChangeObjectNestedImpl(){
                    this.builder = new PipelineTriggerCodeChangeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTriggerCodeChangeObject(builder.build());
    }
    public N endPipelineTriggerCodeChangeObject(){
            return and();
    }

}
    public class NamedExtensionObjectNestedImpl extends NamedExtensionFluentImpl> implements WatchEventFluent.NamedExtensionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamedExtensionBuilder builder;
    
            NamedExtensionObjectNestedImpl(NamedExtension item){
                    this.builder = new NamedExtensionBuilder(this, item);
            }
            NamedExtensionObjectNestedImpl(){
                    this.builder = new NamedExtensionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamedExtensionObject(builder.build());
    }
    public N endNamedExtensionObject(){
            return and();
    }

}
    public class ServiceListObjectNestedImpl extends ServiceListFluentImpl> implements WatchEventFluent.ServiceListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceListBuilder builder;
    
            ServiceListObjectNestedImpl(ServiceList item){
                    this.builder = new ServiceListBuilder(this, item);
            }
            ServiceListObjectNestedImpl(){
                    this.builder = new ServiceListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServiceListObject(builder.build());
    }
    public N endServiceListObject(){
            return and();
    }

}
    public class IngressStatusObjectNestedImpl extends IngressStatusFluentImpl> implements WatchEventFluent.IngressStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressStatusBuilder builder;
    
            IngressStatusObjectNestedImpl(IngressStatus item){
                    this.builder = new IngressStatusBuilder(this, item);
            }
            IngressStatusObjectNestedImpl(){
                    this.builder = new IngressStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressStatusObject(builder.build());
    }
    public N endIngressStatusObject(){
            return and();
    }

}
    public class InitializersObjectNestedImpl extends InitializersFluentImpl> implements WatchEventFluent.InitializersObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final InitializersBuilder builder;
    
            InitializersObjectNestedImpl(Initializers item){
                    this.builder = new InitializersBuilder(this, item);
            }
            InitializersObjectNestedImpl(){
                    this.builder = new InitializersBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withInitializersObject(builder.build());
    }
    public N endInitializersObject(){
            return and();
    }

}
    public class SecretKeySelectorObjectNestedImpl extends SecretKeySelectorFluentImpl> implements WatchEventFluent.SecretKeySelectorObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretKeySelectorBuilder builder;
    
            SecretKeySelectorObjectNestedImpl(SecretKeySelector item){
                    this.builder = new SecretKeySelectorBuilder(this, item);
            }
            SecretKeySelectorObjectNestedImpl(){
                    this.builder = new SecretKeySelectorBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretKeySelectorObject(builder.build());
    }
    public N endSecretKeySelectorObject(){
            return and();
    }

}
    public class PodConditionObjectNestedImpl extends PodConditionFluentImpl> implements WatchEventFluent.PodConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodConditionBuilder builder;
    
            PodConditionObjectNestedImpl(PodCondition item){
                    this.builder = new PodConditionBuilder(this, item);
            }
            PodConditionObjectNestedImpl(){
                    this.builder = new PodConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodConditionObject(builder.build());
    }
    public N endPodConditionObject(){
            return and();
    }

}
    public class SupplementalGroupsStrategyOptionsObjectNestedImpl extends SupplementalGroupsStrategyOptionsFluentImpl> implements WatchEventFluent.SupplementalGroupsStrategyOptionsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SupplementalGroupsStrategyOptionsBuilder builder;
    
            SupplementalGroupsStrategyOptionsObjectNestedImpl(SupplementalGroupsStrategyOptions item){
                    this.builder = new SupplementalGroupsStrategyOptionsBuilder(this, item);
            }
            SupplementalGroupsStrategyOptionsObjectNestedImpl(){
                    this.builder = new SupplementalGroupsStrategyOptionsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSupplementalGroupsStrategyOptionsObject(builder.build());
    }
    public N endSupplementalGroupsStrategyOptionsObject(){
            return and();
    }

}
    public class ContainerStateTerminatedObjectNestedImpl extends ContainerStateTerminatedFluentImpl> implements WatchEventFluent.ContainerStateTerminatedObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerStateTerminatedBuilder builder;
    
            ContainerStateTerminatedObjectNestedImpl(ContainerStateTerminated item){
                    this.builder = new ContainerStateTerminatedBuilder(this, item);
            }
            ContainerStateTerminatedObjectNestedImpl(){
                    this.builder = new ContainerStateTerminatedBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerStateTerminatedObject(builder.build());
    }
    public N endContainerStateTerminatedObject(){
            return and();
    }

}
    public class HostPortStatusObjectNestedImpl extends HostPortStatusFluentImpl> implements WatchEventFluent.HostPortStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HostPortStatusBuilder builder;
    
            HostPortStatusObjectNestedImpl(HostPortStatus item){
                    this.builder = new HostPortStatusBuilder(this, item);
            }
            HostPortStatusObjectNestedImpl(){
                    this.builder = new HostPortStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHostPortStatusObject(builder.build());
    }
    public N endHostPortStatusObject(){
            return and();
    }

}
    public class ReplicaSetSpecObjectNestedImpl extends ReplicaSetSpecFluentImpl> implements WatchEventFluent.ReplicaSetSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetSpecBuilder builder;
    
            ReplicaSetSpecObjectNestedImpl(ReplicaSetSpec item){
                    this.builder = new ReplicaSetSpecBuilder(this, item);
            }
            ReplicaSetSpecObjectNestedImpl(){
                    this.builder = new ReplicaSetSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicaSetSpecObject(builder.build());
    }
    public N endReplicaSetSpecObject(){
            return and();
    }

}
    public class PipelineSourceGitObjectNestedImpl extends PipelineSourceGitFluentImpl> implements WatchEventFluent.PipelineSourceGitObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineSourceGitBuilder builder;
    
            PipelineSourceGitObjectNestedImpl(PipelineSourceGit item){
                    this.builder = new PipelineSourceGitBuilder(this, item);
            }
            PipelineSourceGitObjectNestedImpl(){
                    this.builder = new PipelineSourceGitBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineSourceGitObject(builder.build());
    }
    public N endPipelineSourceGitObject(){
            return and();
    }

}
    public class ISCSIVolumeSourceObjectNestedImpl extends ISCSIVolumeSourceFluentImpl> implements WatchEventFluent.ISCSIVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ISCSIVolumeSourceBuilder builder;
    
            ISCSIVolumeSourceObjectNestedImpl(ISCSIVolumeSource item){
                    this.builder = new ISCSIVolumeSourceBuilder(this, item);
            }
            ISCSIVolumeSourceObjectNestedImpl(){
                    this.builder = new ISCSIVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withISCSIVolumeSourceObject(builder.build());
    }
    public N endISCSIVolumeSourceObject(){
            return and();
    }

}
    public class AzureDiskVolumeSourceObjectNestedImpl extends AzureDiskVolumeSourceFluentImpl> implements WatchEventFluent.AzureDiskVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AzureDiskVolumeSourceBuilder builder;
    
            AzureDiskVolumeSourceObjectNestedImpl(AzureDiskVolumeSource item){
                    this.builder = new AzureDiskVolumeSourceBuilder(this, item);
            }
            AzureDiskVolumeSourceObjectNestedImpl(){
                    this.builder = new AzureDiskVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAzureDiskVolumeSourceObject(builder.build());
    }
    public N endAzureDiskVolumeSourceObject(){
            return and();
    }

}
    public class PipelineTaskArgumentWhenObjectNestedImpl extends PipelineTaskArgumentWhenFluentImpl> implements WatchEventFluent.PipelineTaskArgumentWhenObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentWhenBuilder builder;
    
            PipelineTaskArgumentWhenObjectNestedImpl(PipelineTaskArgumentWhen item){
                    this.builder = new PipelineTaskArgumentWhenBuilder(this, item);
            }
            PipelineTaskArgumentWhenObjectNestedImpl(){
                    this.builder = new PipelineTaskArgumentWhenBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskArgumentWhenObject(builder.build());
    }
    public N endPipelineTaskArgumentWhenObject(){
            return and();
    }

}
    public class DownwardAPIVolumeSourceObjectNestedImpl extends DownwardAPIVolumeSourceFluentImpl> implements WatchEventFluent.DownwardAPIVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DownwardAPIVolumeSourceBuilder builder;
    
            DownwardAPIVolumeSourceObjectNestedImpl(DownwardAPIVolumeSource item){
                    this.builder = new DownwardAPIVolumeSourceBuilder(this, item);
            }
            DownwardAPIVolumeSourceObjectNestedImpl(){
                    this.builder = new DownwardAPIVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDownwardAPIVolumeSourceObject(builder.build());
    }
    public N endDownwardAPIVolumeSourceObject(){
            return and();
    }

}
    public class StorageClassListObjectNestedImpl extends StorageClassListFluentImpl> implements WatchEventFluent.StorageClassListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageClassListBuilder builder;
    
            StorageClassListObjectNestedImpl(StorageClassList item){
                    this.builder = new StorageClassListBuilder(this, item);
            }
            StorageClassListObjectNestedImpl(){
                    this.builder = new StorageClassListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStorageClassListObject(builder.build());
    }
    public N endStorageClassListObject(){
            return and();
    }

}
    public class GitRepoVolumeSourceObjectNestedImpl extends GitRepoVolumeSourceFluentImpl> implements WatchEventFluent.GitRepoVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final GitRepoVolumeSourceBuilder builder;
    
            GitRepoVolumeSourceObjectNestedImpl(GitRepoVolumeSource item){
                    this.builder = new GitRepoVolumeSourceBuilder(this, item);
            }
            GitRepoVolumeSourceObjectNestedImpl(){
                    this.builder = new GitRepoVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withGitRepoVolumeSourceObject(builder.build());
    }
    public N endGitRepoVolumeSourceObject(){
            return and();
    }

}
    public class CodeRepositoryRefObjectNestedImpl extends CodeRepositoryRefFluentImpl> implements WatchEventFluent.CodeRepositoryRefObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryRefBuilder builder;
    
            CodeRepositoryRefObjectNestedImpl(CodeRepositoryRef item){
                    this.builder = new CodeRepositoryRefBuilder(this, item);
            }
            CodeRepositoryRefObjectNestedImpl(){
                    this.builder = new CodeRepositoryRefBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositoryRefObject(builder.build());
    }
    public N endCodeRepositoryRefObject(){
            return and();
    }

}
    public class PodTemplateSpecObjectNestedImpl extends PodTemplateSpecFluentImpl> implements WatchEventFluent.PodTemplateSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateSpecBuilder builder;
    
            PodTemplateSpecObjectNestedImpl(PodTemplateSpec item){
                    this.builder = new PodTemplateSpecBuilder(this, item);
            }
            PodTemplateSpecObjectNestedImpl(){
                    this.builder = new PodTemplateSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodTemplateSpecObject(builder.build());
    }
    public N endPodTemplateSpecObject(){
            return and();
    }

}
    public class JenkinsSpecObjectNestedImpl extends JenkinsSpecFluentImpl> implements WatchEventFluent.JenkinsSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsSpecBuilder builder;
    
            JenkinsSpecObjectNestedImpl(JenkinsSpec item){
                    this.builder = new JenkinsSpecBuilder(this, item);
            }
            JenkinsSpecObjectNestedImpl(){
                    this.builder = new JenkinsSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsSpecObject(builder.build());
    }
    public N endJenkinsSpecObject(){
            return and();
    }

}
    public class PipelineTemplateTaskInstanceSpecObjectNestedImpl extends PipelineTemplateTaskInstanceSpecFluentImpl> implements WatchEventFluent.PipelineTemplateTaskInstanceSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateTaskInstanceSpecBuilder builder;
    
            PipelineTemplateTaskInstanceSpecObjectNestedImpl(PipelineTemplateTaskInstanceSpec item){
                    this.builder = new PipelineTemplateTaskInstanceSpecBuilder(this, item);
            }
            PipelineTemplateTaskInstanceSpecObjectNestedImpl(){
                    this.builder = new PipelineTemplateTaskInstanceSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateTaskInstanceSpecObject(builder.build());
    }
    public N endPipelineTemplateTaskInstanceSpecObject(){
            return and();
    }

}
    public class ContainerStateRunningObjectNestedImpl extends ContainerStateRunningFluentImpl> implements WatchEventFluent.ContainerStateRunningObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerStateRunningBuilder builder;
    
            ContainerStateRunningObjectNestedImpl(ContainerStateRunning item){
                    this.builder = new ContainerStateRunningBuilder(this, item);
            }
            ContainerStateRunningObjectNestedImpl(){
                    this.builder = new ContainerStateRunningBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerStateRunningObject(builder.build());
    }
    public N endContainerStateRunningObject(){
            return and();
    }

}
    public class OwnerReferenceObjectNestedImpl extends OwnerReferenceFluentImpl> implements WatchEventFluent.OwnerReferenceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final OwnerReferenceBuilder builder;
    
            OwnerReferenceObjectNestedImpl(OwnerReference item){
                    this.builder = new OwnerReferenceBuilder(this, item);
            }
            OwnerReferenceObjectNestedImpl(){
                    this.builder = new OwnerReferenceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withOwnerReferenceObject(builder.build());
    }
    public N endOwnerReferenceObject(){
            return and();
    }

}
    public class ConfigMapVolumeSourceObjectNestedImpl extends ConfigMapVolumeSourceFluentImpl> implements WatchEventFluent.ConfigMapVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapVolumeSourceBuilder builder;
    
            ConfigMapVolumeSourceObjectNestedImpl(ConfigMapVolumeSource item){
                    this.builder = new ConfigMapVolumeSourceBuilder(this, item);
            }
            ConfigMapVolumeSourceObjectNestedImpl(){
                    this.builder = new ConfigMapVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigMapVolumeSourceObject(builder.build());
    }
    public N endConfigMapVolumeSourceObject(){
            return and();
    }

}
    public class LabelSelectorRequirementObjectNestedImpl extends LabelSelectorRequirementFluentImpl> implements WatchEventFluent.LabelSelectorRequirementObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LabelSelectorRequirementBuilder builder;
    
            LabelSelectorRequirementObjectNestedImpl(LabelSelectorRequirement item){
                    this.builder = new LabelSelectorRequirementBuilder(this, item);
            }
            LabelSelectorRequirementObjectNestedImpl(){
                    this.builder = new LabelSelectorRequirementBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLabelSelectorRequirementObject(builder.build());
    }
    public N endLabelSelectorRequirementObject(){
            return and();
    }

}
    public class JenkinsInstanceObjectNestedImpl extends JenkinsInstanceFluentImpl> implements WatchEventFluent.JenkinsInstanceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsInstanceBuilder builder;
    
            JenkinsInstanceObjectNestedImpl(JenkinsInstance item){
                    this.builder = new JenkinsInstanceBuilder(this, item);
            }
            JenkinsInstanceObjectNestedImpl(){
                    this.builder = new JenkinsInstanceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsInstanceObject(builder.build());
    }
    public N endJenkinsInstanceObject(){
            return and();
    }

}
    public class ResourceAttributesObjectNestedImpl extends ResourceAttributesFluentImpl> implements WatchEventFluent.ResourceAttributesObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceAttributesBuilder builder;
    
            ResourceAttributesObjectNestedImpl(ResourceAttributes item){
                    this.builder = new ResourceAttributesBuilder(this, item);
            }
            ResourceAttributesObjectNestedImpl(){
                    this.builder = new ResourceAttributesBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceAttributesObject(builder.build());
    }
    public N endResourceAttributesObject(){
            return and();
    }

}
    public class FlockerVolumeSourceObjectNestedImpl extends FlockerVolumeSourceFluentImpl> implements WatchEventFluent.FlockerVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final FlockerVolumeSourceBuilder builder;
    
            FlockerVolumeSourceObjectNestedImpl(FlockerVolumeSource item){
                    this.builder = new FlockerVolumeSourceBuilder(this, item);
            }
            FlockerVolumeSourceObjectNestedImpl(){
                    this.builder = new FlockerVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withFlockerVolumeSourceObject(builder.build());
    }
    public N endFlockerVolumeSourceObject(){
            return and();
    }

}
    public class PodAntiAffinityObjectNestedImpl extends PodAntiAffinityFluentImpl> implements WatchEventFluent.PodAntiAffinityObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodAntiAffinityBuilder builder;
    
            PodAntiAffinityObjectNestedImpl(PodAntiAffinity item){
                    this.builder = new PodAntiAffinityBuilder(this, item);
            }
            PodAntiAffinityObjectNestedImpl(){
                    this.builder = new PodAntiAffinityBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodAntiAffinityObject(builder.build());
    }
    public N endPodAntiAffinityObject(){
            return and();
    }

}
    public class NamedContextObjectNestedImpl extends NamedContextFluentImpl> implements WatchEventFluent.NamedContextObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamedContextBuilder builder;
    
            NamedContextObjectNestedImpl(NamedContext item){
                    this.builder = new NamedContextBuilder(this, item);
            }
            NamedContextObjectNestedImpl(){
                    this.builder = new NamedContextBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamedContextObject(builder.build());
    }
    public N endNamedContextObject(){
            return and();
    }

}
    public class EnvVarObjectNestedImpl extends EnvVarFluentImpl> implements WatchEventFluent.EnvVarObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EnvVarBuilder builder;
    
            EnvVarObjectNestedImpl(EnvVar item){
                    this.builder = new EnvVarBuilder(this, item);
            }
            EnvVarObjectNestedImpl(){
                    this.builder = new EnvVarBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEnvVarObject(builder.build());
    }
    public N endEnvVarObject(){
            return and();
    }

}
    public class ScaleIOVolumeSourceObjectNestedImpl extends ScaleIOVolumeSourceFluentImpl> implements WatchEventFluent.ScaleIOVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleIOVolumeSourceBuilder builder;
    
            ScaleIOVolumeSourceObjectNestedImpl(ScaleIOVolumeSource item){
                    this.builder = new ScaleIOVolumeSourceBuilder(this, item);
            }
            ScaleIOVolumeSourceObjectNestedImpl(){
                    this.builder = new ScaleIOVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withScaleIOVolumeSourceObject(builder.build());
    }
    public N endScaleIOVolumeSourceObject(){
            return and();
    }

}
    public class MultiBranchPipelineObjectNestedImpl extends MultiBranchPipelineFluentImpl> implements WatchEventFluent.MultiBranchPipelineObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final MultiBranchPipelineBuilder builder;
    
            MultiBranchPipelineObjectNestedImpl(MultiBranchPipeline item){
                    this.builder = new MultiBranchPipelineBuilder(this, item);
            }
            MultiBranchPipelineObjectNestedImpl(){
                    this.builder = new MultiBranchPipelineBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withMultiBranchPipelineObject(builder.build());
    }
    public N endMultiBranchPipelineObject(){
            return and();
    }

}
    public class HandlerObjectNestedImpl extends HandlerFluentImpl> implements WatchEventFluent.HandlerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HandlerBuilder builder;
    
            HandlerObjectNestedImpl(Handler item){
                    this.builder = new HandlerBuilder(this, item);
            }
            HandlerObjectNestedImpl(){
                    this.builder = new HandlerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHandlerObject(builder.build());
    }
    public N endHandlerObject(){
            return and();
    }

}
    public class ServiceStatusObjectNestedImpl extends ServiceStatusFluentImpl> implements WatchEventFluent.ServiceStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceStatusBuilder builder;
    
            ServiceStatusObjectNestedImpl(ServiceStatus item){
                    this.builder = new ServiceStatusBuilder(this, item);
            }
            ServiceStatusObjectNestedImpl(){
                    this.builder = new ServiceStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServiceStatusObject(builder.build());
    }
    public N endServiceStatusObject(){
            return and();
    }

}
    public class IDRangeObjectNestedImpl extends IDRangeFluentImpl> implements WatchEventFluent.IDRangeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IDRangeBuilder builder;
    
            IDRangeObjectNestedImpl(IDRange item){
                    this.builder = new IDRangeBuilder(this, item);
            }
            IDRangeObjectNestedImpl(){
                    this.builder = new IDRangeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIDRangeObject(builder.build());
    }
    public N endIDRangeObject(){
            return and();
    }

}
    public class HorizontalPodAutoscalerListObjectNestedImpl extends HorizontalPodAutoscalerListFluentImpl> implements WatchEventFluent.HorizontalPodAutoscalerListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerListBuilder builder;
    
            HorizontalPodAutoscalerListObjectNestedImpl(HorizontalPodAutoscalerList item){
                    this.builder = new HorizontalPodAutoscalerListBuilder(this, item);
            }
            HorizontalPodAutoscalerListObjectNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHorizontalPodAutoscalerListObject(builder.build());
    }
    public N endHorizontalPodAutoscalerListObject(){
            return and();
    }

}
    public class ReplicaSetConditionObjectNestedImpl extends ReplicaSetConditionFluentImpl> implements WatchEventFluent.ReplicaSetConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetConditionBuilder builder;
    
            ReplicaSetConditionObjectNestedImpl(ReplicaSetCondition item){
                    this.builder = new ReplicaSetConditionBuilder(this, item);
            }
            ReplicaSetConditionObjectNestedImpl(){
                    this.builder = new ReplicaSetConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicaSetConditionObject(builder.build());
    }
    public N endReplicaSetConditionObject(){
            return and();
    }

}
    public class PipelineSourceObjectNestedImpl extends PipelineSourceFluentImpl> implements WatchEventFluent.PipelineSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineSourceBuilder builder;
    
            PipelineSourceObjectNestedImpl(PipelineSource item){
                    this.builder = new PipelineSourceBuilder(this, item);
            }
            PipelineSourceObjectNestedImpl(){
                    this.builder = new PipelineSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineSourceObject(builder.build());
    }
    public N endPipelineSourceObject(){
            return and();
    }

}
    public class PodStatusObjectNestedImpl extends PodStatusFluentImpl> implements WatchEventFluent.PodStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodStatusBuilder builder;
    
            PodStatusObjectNestedImpl(PodStatus item){
                    this.builder = new PodStatusBuilder(this, item);
            }
            PodStatusObjectNestedImpl(){
                    this.builder = new PodStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodStatusObject(builder.build());
    }
    public N endPodStatusObject(){
            return and();
    }

}
    public class AuthProviderConfigObjectNestedImpl extends AuthProviderConfigFluentImpl> implements WatchEventFluent.AuthProviderConfigObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final AuthProviderConfigBuilder builder;
    
            AuthProviderConfigObjectNestedImpl(AuthProviderConfig item){
                    this.builder = new AuthProviderConfigBuilder(this, item);
            }
            AuthProviderConfigObjectNestedImpl(){
                    this.builder = new AuthProviderConfigBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAuthProviderConfigObject(builder.build());
    }
    public N endAuthProviderConfigObject(){
            return and();
    }

}
    public class JenkinsPluginObjectNestedImpl extends JenkinsPluginFluentImpl> implements WatchEventFluent.JenkinsPluginObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsPluginBuilder builder;
    
            JenkinsPluginObjectNestedImpl(JenkinsPlugin item){
                    this.builder = new JenkinsPluginBuilder(this, item);
            }
            JenkinsPluginObjectNestedImpl(){
                    this.builder = new JenkinsPluginBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsPluginObject(builder.build());
    }
    public N endJenkinsPluginObject(){
            return and();
    }

}
    public class GCEPersistentDiskVolumeSourceObjectNestedImpl extends GCEPersistentDiskVolumeSourceFluentImpl> implements WatchEventFluent.GCEPersistentDiskVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final GCEPersistentDiskVolumeSourceBuilder builder;
    
            GCEPersistentDiskVolumeSourceObjectNestedImpl(GCEPersistentDiskVolumeSource item){
                    this.builder = new GCEPersistentDiskVolumeSourceBuilder(this, item);
            }
            GCEPersistentDiskVolumeSourceObjectNestedImpl(){
                    this.builder = new GCEPersistentDiskVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withGCEPersistentDiskVolumeSourceObject(builder.build());
    }
    public N endGCEPersistentDiskVolumeSourceObject(){
            return and();
    }

}
    public class EmptyDirVolumeSourceObjectNestedImpl extends EmptyDirVolumeSourceFluentImpl> implements WatchEventFluent.EmptyDirVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EmptyDirVolumeSourceBuilder builder;
    
            EmptyDirVolumeSourceObjectNestedImpl(EmptyDirVolumeSource item){
                    this.builder = new EmptyDirVolumeSourceBuilder(this, item);
            }
            EmptyDirVolumeSourceObjectNestedImpl(){
                    this.builder = new EmptyDirVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEmptyDirVolumeSourceObject(builder.build());
    }
    public N endEmptyDirVolumeSourceObject(){
            return and();
    }

}
    public class CodeRepoBindingObjectNestedImpl extends CodeRepoBindingFluentImpl> implements WatchEventFluent.CodeRepoBindingObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoBindingBuilder builder;
    
            CodeRepoBindingObjectNestedImpl(CodeRepoBinding item){
                    this.builder = new CodeRepoBindingBuilder(this, item);
            }
            CodeRepoBindingObjectNestedImpl(){
                    this.builder = new CodeRepoBindingBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoBindingObject(builder.build());
    }
    public N endCodeRepoBindingObject(){
            return and();
    }

}
    public class PipelineTemplateTaskObjectNestedImpl extends PipelineTemplateTaskFluentImpl> implements WatchEventFluent.PipelineTemplateTaskObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateTaskBuilder builder;
    
            PipelineTemplateTaskObjectNestedImpl(PipelineTemplateTask item){
                    this.builder = new PipelineTemplateTaskBuilder(this, item);
            }
            PipelineTemplateTaskObjectNestedImpl(){
                    this.builder = new PipelineTemplateTaskBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateTaskObject(builder.build());
    }
    public N endPipelineTemplateTaskObject(){
            return and();
    }

}
    public class ScaleObjectNestedImpl extends ScaleFluentImpl> implements WatchEventFluent.ScaleObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleBuilder builder;
    
            ScaleObjectNestedImpl(Scale item){
                    this.builder = new ScaleBuilder(this, item);
            }
            ScaleObjectNestedImpl(){
                    this.builder = new ScaleBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withScaleObject(builder.build());
    }
    public N endScaleObject(){
            return and();
    }

}
    public class PipelineTaskTemplateObjectNestedImpl extends PipelineTaskTemplateFluentImpl> implements WatchEventFluent.PipelineTaskTemplateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskTemplateBuilder builder;
    
            PipelineTaskTemplateObjectNestedImpl(PipelineTaskTemplate item){
                    this.builder = new PipelineTaskTemplateBuilder(this, item);
            }
            PipelineTaskTemplateObjectNestedImpl(){
                    this.builder = new PipelineTaskTemplateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskTemplateObject(builder.build());
    }
    public N endPipelineTaskTemplateObject(){
            return and();
    }

}
    public class PodSpecObjectNestedImpl extends PodSpecFluentImpl> implements WatchEventFluent.PodSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSpecBuilder builder;
    
            PodSpecObjectNestedImpl(PodSpec item){
                    this.builder = new PodSpecBuilder(this, item);
            }
            PodSpecObjectNestedImpl(){
                    this.builder = new PodSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodSpecObject(builder.build());
    }
    public N endPodSpecObject(){
            return and();
    }

}
    public class NodeSpecObjectNestedImpl extends NodeSpecFluentImpl> implements WatchEventFluent.NodeSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeSpecBuilder builder;
    
            NodeSpecObjectNestedImpl(NodeSpec item){
                    this.builder = new NodeSpecBuilder(this, item);
            }
            NodeSpecObjectNestedImpl(){
                    this.builder = new NodeSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeSpecObject(builder.build());
    }
    public N endNodeSpecObject(){
            return and();
    }

}
    public class PipelineConfigSpecObjectNestedImpl extends PipelineConfigSpecFluentImpl> implements WatchEventFluent.PipelineConfigSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigSpecBuilder builder;
    
            PipelineConfigSpecObjectNestedImpl(PipelineConfigSpec item){
                    this.builder = new PipelineConfigSpecBuilder(this, item);
            }
            PipelineConfigSpecObjectNestedImpl(){
                    this.builder = new PipelineConfigSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineConfigSpecObject(builder.build());
    }
    public N endPipelineConfigSpecObject(){
            return and();
    }

}
    public class ComponentConditionObjectNestedImpl extends ComponentConditionFluentImpl> implements WatchEventFluent.ComponentConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentConditionBuilder builder;
    
            ComponentConditionObjectNestedImpl(ComponentCondition item){
                    this.builder = new ComponentConditionBuilder(this, item);
            }
            ComponentConditionObjectNestedImpl(){
                    this.builder = new ComponentConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withComponentConditionObject(builder.build());
    }
    public N endComponentConditionObject(){
            return and();
    }

}
    public class PodObjectNestedImpl extends PodFluentImpl> implements WatchEventFluent.PodObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodBuilder builder;
    
            PodObjectNestedImpl(Pod item){
                    this.builder = new PodBuilder(this, item);
            }
            PodObjectNestedImpl(){
                    this.builder = new PodBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodObject(builder.build());
    }
    public N endPodObject(){
            return and();
    }

}
    public class CephFSVolumeSourceObjectNestedImpl extends CephFSVolumeSourceFluentImpl> implements WatchEventFluent.CephFSVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CephFSVolumeSourceBuilder builder;
    
            CephFSVolumeSourceObjectNestedImpl(CephFSVolumeSource item){
                    this.builder = new CephFSVolumeSourceBuilder(this, item);
            }
            CephFSVolumeSourceObjectNestedImpl(){
                    this.builder = new CephFSVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCephFSVolumeSourceObject(builder.build());
    }
    public N endCephFSVolumeSourceObject(){
            return and();
    }

}
    public class CodeRepositoryOwnerSyncObjectNestedImpl extends CodeRepositoryOwnerSyncFluentImpl> implements WatchEventFluent.CodeRepositoryOwnerSyncObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryOwnerSyncBuilder builder;
    
            CodeRepositoryOwnerSyncObjectNestedImpl(CodeRepositoryOwnerSync item){
                    this.builder = new CodeRepositoryOwnerSyncBuilder(this, item);
            }
            CodeRepositoryOwnerSyncObjectNestedImpl(){
                    this.builder = new CodeRepositoryOwnerSyncBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositoryOwnerSyncObject(builder.build());
    }
    public N endCodeRepositoryOwnerSyncObject(){
            return and();
    }

}
    public class ReplicationControllerConditionObjectNestedImpl extends ReplicationControllerConditionFluentImpl> implements WatchEventFluent.ReplicationControllerConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerConditionBuilder builder;
    
            ReplicationControllerConditionObjectNestedImpl(ReplicationControllerCondition item){
                    this.builder = new ReplicationControllerConditionBuilder(this, item);
            }
            ReplicationControllerConditionObjectNestedImpl(){
                    this.builder = new ReplicationControllerConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicationControllerConditionObject(builder.build());
    }
    public N endReplicationControllerConditionObject(){
            return and();
    }

}
    public class HorizontalPodAutoscalerObjectNestedImpl extends HorizontalPodAutoscalerFluentImpl> implements WatchEventFluent.HorizontalPodAutoscalerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerBuilder builder;
    
            HorizontalPodAutoscalerObjectNestedImpl(HorizontalPodAutoscaler item){
                    this.builder = new HorizontalPodAutoscalerBuilder(this, item);
            }
            HorizontalPodAutoscalerObjectNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHorizontalPodAutoscalerObject(builder.build());
    }
    public N endHorizontalPodAutoscalerObject(){
            return and();
    }

}
    public class ConfigMapProjectionObjectNestedImpl extends ConfigMapProjectionFluentImpl> implements WatchEventFluent.ConfigMapProjectionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapProjectionBuilder builder;
    
            ConfigMapProjectionObjectNestedImpl(ConfigMapProjection item){
                    this.builder = new ConfigMapProjectionBuilder(this, item);
            }
            ConfigMapProjectionObjectNestedImpl(){
                    this.builder = new ConfigMapProjectionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigMapProjectionObject(builder.build());
    }
    public N endConfigMapProjectionObject(){
            return and();
    }

}
    public class CrossVersionObjectReferenceObjectNestedImpl extends CrossVersionObjectReferenceFluentImpl> implements WatchEventFluent.CrossVersionObjectReferenceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CrossVersionObjectReferenceBuilder builder;
    
            CrossVersionObjectReferenceObjectNestedImpl(CrossVersionObjectReference item){
                    this.builder = new CrossVersionObjectReferenceBuilder(this, item);
            }
            CrossVersionObjectReferenceObjectNestedImpl(){
                    this.builder = new CrossVersionObjectReferenceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCrossVersionObjectReferenceObject(builder.build());
    }
    public N endCrossVersionObjectReferenceObject(){
            return and();
    }

}
    public class ClusterObjectNestedImpl extends ClusterFluentImpl> implements WatchEventFluent.ClusterObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterBuilder builder;
    
            ClusterObjectNestedImpl(Cluster item){
                    this.builder = new ClusterBuilder(this, item);
            }
            ClusterObjectNestedImpl(){
                    this.builder = new ClusterBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withClusterObject(builder.build());
    }
    public N endClusterObject(){
            return and();
    }

}
    public class PersistentVolumeClaimStatusObjectNestedImpl extends PersistentVolumeClaimStatusFluentImpl> implements WatchEventFluent.PersistentVolumeClaimStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimStatusBuilder builder;
    
            PersistentVolumeClaimStatusObjectNestedImpl(PersistentVolumeClaimStatus item){
                    this.builder = new PersistentVolumeClaimStatusBuilder(this, item);
            }
            PersistentVolumeClaimStatusObjectNestedImpl(){
                    this.builder = new PersistentVolumeClaimStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeClaimStatusObject(builder.build());
    }
    public N endPersistentVolumeClaimStatusObject(){
            return and();
    }

}
    public class NetworkPolicyIngressRuleObjectNestedImpl extends NetworkPolicyIngressRuleFluentImpl> implements WatchEventFluent.NetworkPolicyIngressRuleObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyIngressRuleBuilder builder;
    
            NetworkPolicyIngressRuleObjectNestedImpl(NetworkPolicyIngressRule item){
                    this.builder = new NetworkPolicyIngressRuleBuilder(this, item);
            }
            NetworkPolicyIngressRuleObjectNestedImpl(){
                    this.builder = new NetworkPolicyIngressRuleBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNetworkPolicyIngressRuleObject(builder.build());
    }
    public N endNetworkPolicyIngressRuleObject(){
            return and();
    }

}
    public class LimitRangeListObjectNestedImpl extends LimitRangeListFluentImpl> implements WatchEventFluent.LimitRangeListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeListBuilder builder;
    
            LimitRangeListObjectNestedImpl(LimitRangeList item){
                    this.builder = new LimitRangeListBuilder(this, item);
            }
            LimitRangeListObjectNestedImpl(){
                    this.builder = new LimitRangeListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLimitRangeListObject(builder.build());
    }
    public N endLimitRangeListObject(){
            return and();
    }

}
    public class EndpointAddressObjectNestedImpl extends EndpointAddressFluentImpl> implements WatchEventFluent.EndpointAddressObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointAddressBuilder builder;
    
            EndpointAddressObjectNestedImpl(EndpointAddress item){
                    this.builder = new EndpointAddressBuilder(this, item);
            }
            EndpointAddressObjectNestedImpl(){
                    this.builder = new EndpointAddressBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEndpointAddressObject(builder.build());
    }
    public N endEndpointAddressObject(){
            return and();
    }

}
    public class ProbeObjectNestedImpl extends ProbeFluentImpl> implements WatchEventFluent.ProbeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProbeBuilder builder;
    
            ProbeObjectNestedImpl(Probe item){
                    this.builder = new ProbeBuilder(this, item);
            }
            ProbeObjectNestedImpl(){
                    this.builder = new ProbeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProbeObject(builder.build());
    }
    public N endProbeObject(){
            return and();
    }

}
    public class ConfigMapKeySelectorObjectNestedImpl extends ConfigMapKeySelectorFluentImpl> implements WatchEventFluent.ConfigMapKeySelectorObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapKeySelectorBuilder builder;
    
            ConfigMapKeySelectorObjectNestedImpl(ConfigMapKeySelector item){
                    this.builder = new ConfigMapKeySelectorBuilder(this, item);
            }
            ConfigMapKeySelectorObjectNestedImpl(){
                    this.builder = new ConfigMapKeySelectorBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigMapKeySelectorObject(builder.build());
    }
    public N endConfigMapKeySelectorObject(){
            return and();
    }

}
    public class PipelineTemplateArgumentGroupObjectNestedImpl extends PipelineTemplateArgumentGroupFluentImpl> implements WatchEventFluent.PipelineTemplateArgumentGroupObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateArgumentGroupBuilder builder;
    
            PipelineTemplateArgumentGroupObjectNestedImpl(PipelineTemplateArgumentGroup item){
                    this.builder = new PipelineTemplateArgumentGroupBuilder(this, item);
            }
            PipelineTemplateArgumentGroupObjectNestedImpl(){
                    this.builder = new PipelineTemplateArgumentGroupBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateArgumentGroupObject(builder.build());
    }
    public N endPipelineTemplateArgumentGroupObject(){
            return and();
    }

}
    public class PipelineTaskTemplateSpecObjectNestedImpl extends PipelineTaskTemplateSpecFluentImpl> implements WatchEventFluent.PipelineTaskTemplateSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskTemplateSpecBuilder builder;
    
            PipelineTaskTemplateSpecObjectNestedImpl(PipelineTaskTemplateSpec item){
                    this.builder = new PipelineTaskTemplateSpecBuilder(this, item);
            }
            PipelineTaskTemplateSpecObjectNestedImpl(){
                    this.builder = new PipelineTaskTemplateSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskTemplateSpecObject(builder.build());
    }
    public N endPipelineTaskTemplateSpecObject(){
            return and();
    }

}
    public class CodeRepoServiceListObjectNestedImpl extends CodeRepoServiceListFluentImpl> implements WatchEventFluent.CodeRepoServiceListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepoServiceListBuilder builder;
    
            CodeRepoServiceListObjectNestedImpl(CodeRepoServiceList item){
                    this.builder = new CodeRepoServiceListBuilder(this, item);
            }
            CodeRepoServiceListObjectNestedImpl(){
                    this.builder = new CodeRepoServiceListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepoServiceListObject(builder.build());
    }
    public N endCodeRepoServiceListObject(){
            return and();
    }

}
    public class PodAffinityTermObjectNestedImpl extends PodAffinityTermFluentImpl> implements WatchEventFluent.PodAffinityTermObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodAffinityTermBuilder builder;
    
            PodAffinityTermObjectNestedImpl(PodAffinityTerm item){
                    this.builder = new PodAffinityTermBuilder(this, item);
            }
            PodAffinityTermObjectNestedImpl(){
                    this.builder = new PodAffinityTermBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodAffinityTermObject(builder.build());
    }
    public N endPodAffinityTermObject(){
            return and();
    }

}
    public class JobListObjectNestedImpl extends JobListFluentImpl> implements WatchEventFluent.JobListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobListBuilder builder;
    
            JobListObjectNestedImpl(JobList item){
                    this.builder = new JobListBuilder(this, item);
            }
            JobListObjectNestedImpl(){
                    this.builder = new JobListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJobListObject(builder.build());
    }
    public N endJobListObject(){
            return and();
    }

}
    public class GlusterfsVolumeSourceObjectNestedImpl extends GlusterfsVolumeSourceFluentImpl> implements WatchEventFluent.GlusterfsVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final GlusterfsVolumeSourceBuilder builder;
    
            GlusterfsVolumeSourceObjectNestedImpl(GlusterfsVolumeSource item){
                    this.builder = new GlusterfsVolumeSourceBuilder(this, item);
            }
            GlusterfsVolumeSourceObjectNestedImpl(){
                    this.builder = new GlusterfsVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withGlusterfsVolumeSourceObject(builder.build());
    }
    public N endGlusterfsVolumeSourceObject(){
            return and();
    }

}
    public class ThirdPartyResourceObjectNestedImpl extends ThirdPartyResourceFluentImpl> implements WatchEventFluent.ThirdPartyResourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceBuilder builder;
    
            ThirdPartyResourceObjectNestedImpl(ThirdPartyResource item){
                    this.builder = new ThirdPartyResourceBuilder(this, item);
            }
            ThirdPartyResourceObjectNestedImpl(){
                    this.builder = new ThirdPartyResourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withThirdPartyResourceObject(builder.build());
    }
    public N endThirdPartyResourceObject(){
            return and();
    }

}
    public class PortworxVolumeSourceObjectNestedImpl extends PortworxVolumeSourceFluentImpl> implements WatchEventFluent.PortworxVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PortworxVolumeSourceBuilder builder;
    
            PortworxVolumeSourceObjectNestedImpl(PortworxVolumeSource item){
                    this.builder = new PortworxVolumeSourceBuilder(this, item);
            }
            PortworxVolumeSourceObjectNestedImpl(){
                    this.builder = new PortworxVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPortworxVolumeSourceObject(builder.build());
    }
    public N endPortworxVolumeSourceObject(){
            return and();
    }

}
    public class CronJobListObjectNestedImpl extends CronJobListFluentImpl> implements WatchEventFluent.CronJobListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobListBuilder builder;
    
            CronJobListObjectNestedImpl(CronJobList item){
                    this.builder = new CronJobListBuilder(this, item);
            }
            CronJobListObjectNestedImpl(){
                    this.builder = new CronJobListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCronJobListObject(builder.build());
    }
    public N endCronJobListObject(){
            return and();
    }

}
    public class RBDVolumeSourceObjectNestedImpl extends RBDVolumeSourceFluentImpl> implements WatchEventFluent.RBDVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RBDVolumeSourceBuilder builder;
    
            RBDVolumeSourceObjectNestedImpl(RBDVolumeSource item){
                    this.builder = new RBDVolumeSourceBuilder(this, item);
            }
            RBDVolumeSourceObjectNestedImpl(){
                    this.builder = new RBDVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRBDVolumeSourceObject(builder.build());
    }
    public N endRBDVolumeSourceObject(){
            return and();
    }

}
    public class PipelineHookObjectNestedImpl extends PipelineHookFluentImpl> implements WatchEventFluent.PipelineHookObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineHookBuilder builder;
    
            PipelineHookObjectNestedImpl(PipelineHook item){
                    this.builder = new PipelineHookBuilder(this, item);
            }
            PipelineHookObjectNestedImpl(){
                    this.builder = new PipelineHookBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineHookObject(builder.build());
    }
    public N endPipelineHookObject(){
            return and();
    }

}
    public class CronJobStatusObjectNestedImpl extends CronJobStatusFluentImpl> implements WatchEventFluent.CronJobStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CronJobStatusBuilder builder;
    
            CronJobStatusObjectNestedImpl(CronJobStatus item){
                    this.builder = new CronJobStatusBuilder(this, item);
            }
            CronJobStatusObjectNestedImpl(){
                    this.builder = new CronJobStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCronJobStatusObject(builder.build());
    }
    public N endCronJobStatusObject(){
            return and();
    }

}
    public class StorageOSVolumeSourceObjectNestedImpl extends StorageOSVolumeSourceFluentImpl> implements WatchEventFluent.StorageOSVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StorageOSVolumeSourceBuilder builder;
    
            StorageOSVolumeSourceObjectNestedImpl(StorageOSVolumeSource item){
                    this.builder = new StorageOSVolumeSourceBuilder(this, item);
            }
            StorageOSVolumeSourceObjectNestedImpl(){
                    this.builder = new StorageOSVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStorageOSVolumeSourceObject(builder.build());
    }
    public N endStorageOSVolumeSourceObject(){
            return and();
    }

}
    public class ServiceAccountListObjectNestedImpl extends ServiceAccountListFluentImpl> implements WatchEventFluent.ServiceAccountListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceAccountListBuilder builder;
    
            ServiceAccountListObjectNestedImpl(ServiceAccountList item){
                    this.builder = new ServiceAccountListBuilder(this, item);
            }
            ServiceAccountListObjectNestedImpl(){
                    this.builder = new ServiceAccountListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServiceAccountListObject(builder.build());
    }
    public N endServiceAccountListObject(){
            return and();
    }

}
    public class ComponentStatusObjectNestedImpl extends ComponentStatusFluentImpl> implements WatchEventFluent.ComponentStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ComponentStatusBuilder builder;
    
            ComponentStatusObjectNestedImpl(ComponentStatus item){
                    this.builder = new ComponentStatusBuilder(this, item);
            }
            ComponentStatusObjectNestedImpl(){
                    this.builder = new ComponentStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withComponentStatusObject(builder.build());
    }
    public N endComponentStatusObject(){
            return and();
    }

}
    public class ThirdPartyResourceListObjectNestedImpl extends ThirdPartyResourceListFluentImpl> implements WatchEventFluent.ThirdPartyResourceListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ThirdPartyResourceListBuilder builder;
    
            ThirdPartyResourceListObjectNestedImpl(ThirdPartyResourceList item){
                    this.builder = new ThirdPartyResourceListBuilder(this, item);
            }
            ThirdPartyResourceListObjectNestedImpl(){
                    this.builder = new ThirdPartyResourceListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withThirdPartyResourceListObject(builder.build());
    }
    public N endThirdPartyResourceListObject(){
            return and();
    }

}
    public class ProjectedVolumeSourceObjectNestedImpl extends ProjectedVolumeSourceFluentImpl> implements WatchEventFluent.ProjectedVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectedVolumeSourceBuilder builder;
    
            ProjectedVolumeSourceObjectNestedImpl(ProjectedVolumeSource item){
                    this.builder = new ProjectedVolumeSourceBuilder(this, item);
            }
            ProjectedVolumeSourceObjectNestedImpl(){
                    this.builder = new ProjectedVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectedVolumeSourceObject(builder.build());
    }
    public N endProjectedVolumeSourceObject(){
            return and();
    }

}
    public class HostPortObjectNestedImpl extends HostPortFluentImpl> implements WatchEventFluent.HostPortObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HostPortBuilder builder;
    
            HostPortObjectNestedImpl(HostPort item){
                    this.builder = new HostPortBuilder(this, item);
            }
            HostPortObjectNestedImpl(){
                    this.builder = new HostPortBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHostPortObject(builder.build());
    }
    public N endHostPortObject(){
            return and();
    }

}
    public class IngressBackendObjectNestedImpl extends IngressBackendFluentImpl> implements WatchEventFluent.IngressBackendObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressBackendBuilder builder;
    
            IngressBackendObjectNestedImpl(IngressBackend item){
                    this.builder = new IngressBackendBuilder(this, item);
            }
            IngressBackendObjectNestedImpl(){
                    this.builder = new IngressBackendBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressBackendObject(builder.build());
    }
    public N endIngressBackendObject(){
            return and();
    }

}
    public class PersistentVolumeClaimObjectNestedImpl extends PersistentVolumeClaimFluentImpl> implements WatchEventFluent.PersistentVolumeClaimObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimBuilder builder;
    
            PersistentVolumeClaimObjectNestedImpl(PersistentVolumeClaim item){
                    this.builder = new PersistentVolumeClaimBuilder(this, item);
            }
            PersistentVolumeClaimObjectNestedImpl(){
                    this.builder = new PersistentVolumeClaimBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeClaimObject(builder.build());
    }
    public N endPersistentVolumeClaimObject(){
            return and();
    }

}
    public class PipelineDependencyObjectNestedImpl extends PipelineDependencyFluentImpl> implements WatchEventFluent.PipelineDependencyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineDependencyBuilder builder;
    
            PipelineDependencyObjectNestedImpl(PipelineDependency item){
                    this.builder = new PipelineDependencyBuilder(this, item);
            }
            PipelineDependencyObjectNestedImpl(){
                    this.builder = new PipelineDependencyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineDependencyObject(builder.build());
    }
    public N endPipelineDependencyObject(){
            return and();
    }

}
    public class NetworkPolicyListObjectNestedImpl extends NetworkPolicyListFluentImpl> implements WatchEventFluent.NetworkPolicyListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyListBuilder builder;
    
            NetworkPolicyListObjectNestedImpl(NetworkPolicyList item){
                    this.builder = new NetworkPolicyListBuilder(this, item);
            }
            NetworkPolicyListObjectNestedImpl(){
                    this.builder = new NetworkPolicyListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNetworkPolicyListObject(builder.build());
    }
    public N endNetworkPolicyListObject(){
            return and();
    }

}
    public class ResourceQuotaListObjectNestedImpl extends ResourceQuotaListFluentImpl> implements WatchEventFluent.ResourceQuotaListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaListBuilder builder;
    
            ResourceQuotaListObjectNestedImpl(ResourceQuotaList item){
                    this.builder = new ResourceQuotaListBuilder(this, item);
            }
            ResourceQuotaListObjectNestedImpl(){
                    this.builder = new ResourceQuotaListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceQuotaListObject(builder.build());
    }
    public N endResourceQuotaListObject(){
            return and();
    }

}
    public class ResourceRequirementsObjectNestedImpl extends ResourceRequirementsFluentImpl> implements WatchEventFluent.ResourceRequirementsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceRequirementsBuilder builder;
    
            ResourceRequirementsObjectNestedImpl(ResourceRequirements item){
                    this.builder = new ResourceRequirementsBuilder(this, item);
            }
            ResourceRequirementsObjectNestedImpl(){
                    this.builder = new ResourceRequirementsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceRequirementsObject(builder.build());
    }
    public N endResourceRequirementsObject(){
            return and();
    }

}
    public class SecretObjectNestedImpl extends SecretFluentImpl> implements WatchEventFluent.SecretObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretBuilder builder;
    
            SecretObjectNestedImpl(Secret item){
                    this.builder = new SecretBuilder(this, item);
            }
            SecretObjectNestedImpl(){
                    this.builder = new SecretBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretObject(builder.build());
    }
    public N endSecretObject(){
            return and();
    }

}
    public class JenkinsBindingSpecObjectNestedImpl extends JenkinsBindingSpecFluentImpl> implements WatchEventFluent.JenkinsBindingSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingSpecBuilder builder;
    
            JenkinsBindingSpecObjectNestedImpl(JenkinsBindingSpec item){
                    this.builder = new JenkinsBindingSpecBuilder(this, item);
            }
            JenkinsBindingSpecObjectNestedImpl(){
                    this.builder = new JenkinsBindingSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsBindingSpecObject(builder.build());
    }
    public N endJenkinsBindingSpecObject(){
            return and();
    }

}
    public class PodSecurityContextObjectNestedImpl extends PodSecurityContextFluentImpl> implements WatchEventFluent.PodSecurityContextObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityContextBuilder builder;
    
            PodSecurityContextObjectNestedImpl(PodSecurityContext item){
                    this.builder = new PodSecurityContextBuilder(this, item);
            }
            PodSecurityContextObjectNestedImpl(){
                    this.builder = new PodSecurityContextBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodSecurityContextObject(builder.build());
    }
    public N endPodSecurityContextObject(){
            return and();
    }

}
    public class NodeSystemInfoObjectNestedImpl extends NodeSystemInfoFluentImpl> implements WatchEventFluent.NodeSystemInfoObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeSystemInfoBuilder builder;
    
            NodeSystemInfoObjectNestedImpl(NodeSystemInfo item){
                    this.builder = new NodeSystemInfoBuilder(this, item);
            }
            NodeSystemInfoObjectNestedImpl(){
                    this.builder = new NodeSystemInfoBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeSystemInfoObject(builder.build());
    }
    public N endNodeSystemInfoObject(){
            return and();
    }

}
    public class ReplicationControllerObjectNestedImpl extends ReplicationControllerFluentImpl> implements WatchEventFluent.ReplicationControllerObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerBuilder builder;
    
            ReplicationControllerObjectNestedImpl(ReplicationController item){
                    this.builder = new ReplicationControllerBuilder(this, item);
            }
            ReplicationControllerObjectNestedImpl(){
                    this.builder = new ReplicationControllerBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicationControllerObject(builder.build());
    }
    public N endReplicationControllerObject(){
            return and();
    }

}
    public class CustomResourceDefinitionListObjectNestedImpl extends CustomResourceDefinitionListFluentImpl> implements WatchEventFluent.CustomResourceDefinitionListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionListBuilder builder;
    
            CustomResourceDefinitionListObjectNestedImpl(CustomResourceDefinitionList item){
                    this.builder = new CustomResourceDefinitionListBuilder(this, item);
            }
            CustomResourceDefinitionListObjectNestedImpl(){
                    this.builder = new CustomResourceDefinitionListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCustomResourceDefinitionListObject(builder.build());
    }
    public N endCustomResourceDefinitionListObject(){
            return and();
    }

}
    public class EndpointsObjectNestedImpl extends EndpointsFluentImpl> implements WatchEventFluent.EndpointsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointsBuilder builder;
    
            EndpointsObjectNestedImpl(Endpoints item){
                    this.builder = new EndpointsBuilder(this, item);
            }
            EndpointsObjectNestedImpl(){
                    this.builder = new EndpointsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEndpointsObject(builder.build());
    }
    public N endEndpointsObject(){
            return and();
    }

}
    public class NodeSelectorRequirementObjectNestedImpl extends NodeSelectorRequirementFluentImpl> implements WatchEventFluent.NodeSelectorRequirementObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeSelectorRequirementBuilder builder;
    
            NodeSelectorRequirementObjectNestedImpl(NodeSelectorRequirement item){
                    this.builder = new NodeSelectorRequirementBuilder(this, item);
            }
            NodeSelectorRequirementObjectNestedImpl(){
                    this.builder = new NodeSelectorRequirementBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeSelectorRequirementObject(builder.build());
    }
    public N endNodeSelectorRequirementObject(){
            return and();
    }

}
    public class LimitRangeObjectNestedImpl extends LimitRangeFluentImpl> implements WatchEventFluent.LimitRangeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LimitRangeBuilder builder;
    
            LimitRangeObjectNestedImpl(LimitRange item){
                    this.builder = new LimitRangeBuilder(this, item);
            }
            LimitRangeObjectNestedImpl(){
                    this.builder = new LimitRangeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLimitRangeObject(builder.build());
    }
    public N endLimitRangeObject(){
            return and();
    }

}
    public class LocalObjectReferenceObjectNestedImpl extends LocalObjectReferenceFluentImpl> implements WatchEventFluent.LocalObjectReferenceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LocalObjectReferenceBuilder builder;
    
            LocalObjectReferenceObjectNestedImpl(LocalObjectReference item){
                    this.builder = new LocalObjectReferenceBuilder(this, item);
            }
            LocalObjectReferenceObjectNestedImpl(){
                    this.builder = new LocalObjectReferenceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLocalObjectReferenceObject(builder.build());
    }
    public N endLocalObjectReferenceObject(){
            return and();
    }

}
    public class CustomResourceDefinitionConditionObjectNestedImpl extends CustomResourceDefinitionConditionFluentImpl> implements WatchEventFluent.CustomResourceDefinitionConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionConditionBuilder builder;
    
            CustomResourceDefinitionConditionObjectNestedImpl(CustomResourceDefinitionCondition item){
                    this.builder = new CustomResourceDefinitionConditionBuilder(this, item);
            }
            CustomResourceDefinitionConditionObjectNestedImpl(){
                    this.builder = new CustomResourceDefinitionConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCustomResourceDefinitionConditionObject(builder.build());
    }
    public N endCustomResourceDefinitionConditionObject(){
            return and();
    }

}
    public class RootPathsObjectNestedImpl extends RootPathsFluentImpl> implements WatchEventFluent.RootPathsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RootPathsBuilder builder;
    
            RootPathsObjectNestedImpl(RootPaths item){
                    this.builder = new RootPathsBuilder(this, item);
            }
            RootPathsObjectNestedImpl(){
                    this.builder = new RootPathsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRootPathsObject(builder.build());
    }
    public N endRootPathsObject(){
            return and();
    }

}
    public class VsphereVirtualDiskVolumeSourceObjectNestedImpl extends VsphereVirtualDiskVolumeSourceFluentImpl> implements WatchEventFluent.VsphereVirtualDiskVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final VsphereVirtualDiskVolumeSourceBuilder builder;
    
            VsphereVirtualDiskVolumeSourceObjectNestedImpl(VsphereVirtualDiskVolumeSource item){
                    this.builder = new VsphereVirtualDiskVolumeSourceBuilder(this, item);
            }
            VsphereVirtualDiskVolumeSourceObjectNestedImpl(){
                    this.builder = new VsphereVirtualDiskVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withVsphereVirtualDiskVolumeSourceObject(builder.build());
    }
    public N endVsphereVirtualDiskVolumeSourceObject(){
            return and();
    }

}
    public class DaemonEndpointObjectNestedImpl extends DaemonEndpointFluentImpl> implements WatchEventFluent.DaemonEndpointObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonEndpointBuilder builder;
    
            DaemonEndpointObjectNestedImpl(DaemonEndpoint item){
                    this.builder = new DaemonEndpointBuilder(this, item);
            }
            DaemonEndpointObjectNestedImpl(){
                    this.builder = new DaemonEndpointBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDaemonEndpointObject(builder.build());
    }
    public N endDaemonEndpointObject(){
            return and();
    }

}
    public class KubernetesListObjectNestedImpl extends KubernetesListFluentImpl> implements WatchEventFluent.KubernetesListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final KubernetesListBuilder builder;
    
            KubernetesListObjectNestedImpl(KubernetesList item){
                    this.builder = new KubernetesListBuilder(this, item);
            }
            KubernetesListObjectNestedImpl(){
                    this.builder = new KubernetesListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withKubernetesListObject(builder.build());
    }
    public N endKubernetesListObject(){
            return and();
    }

}
    public class SecretKeySetRefObjectNestedImpl extends SecretKeySetRefFluentImpl> implements WatchEventFluent.SecretKeySetRefObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretKeySetRefBuilder builder;
    
            SecretKeySetRefObjectNestedImpl(SecretKeySetRef item){
                    this.builder = new SecretKeySetRefBuilder(this, item);
            }
            SecretKeySetRefObjectNestedImpl(){
                    this.builder = new SecretKeySetRefBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretKeySetRefObject(builder.build());
    }
    public N endSecretKeySetRefObject(){
            return and();
    }

}
    public class TokenReviewStatusObjectNestedImpl extends TokenReviewStatusFluentImpl> implements WatchEventFluent.TokenReviewStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final TokenReviewStatusBuilder builder;
    
            TokenReviewStatusObjectNestedImpl(TokenReviewStatus item){
                    this.builder = new TokenReviewStatusBuilder(this, item);
            }
            TokenReviewStatusObjectNestedImpl(){
                    this.builder = new TokenReviewStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withTokenReviewStatusObject(builder.build());
    }
    public N endTokenReviewStatusObject(){
            return and();
    }

}
    public class CodeRepositoryStatusRepositoryObjectNestedImpl extends CodeRepositoryStatusRepositoryFluentImpl> implements WatchEventFluent.CodeRepositoryStatusRepositoryObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryStatusRepositoryBuilder builder;
    
            CodeRepositoryStatusRepositoryObjectNestedImpl(CodeRepositoryStatusRepository item){
                    this.builder = new CodeRepositoryStatusRepositoryBuilder(this, item);
            }
            CodeRepositoryStatusRepositoryObjectNestedImpl(){
                    this.builder = new CodeRepositoryStatusRepositoryBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositoryStatusRepositoryObject(builder.build());
    }
    public N endCodeRepositoryStatusRepositoryObject(){
            return and();
    }

}
    public class EventSourceObjectNestedImpl extends EventSourceFluentImpl> implements WatchEventFluent.EventSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventSourceBuilder builder;
    
            EventSourceObjectNestedImpl(EventSource item){
                    this.builder = new EventSourceBuilder(this, item);
            }
            EventSourceObjectNestedImpl(){
                    this.builder = new EventSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEventSourceObject(builder.build());
    }
    public N endEventSourceObject(){
            return and();
    }

}
    public class NetworkPolicyObjectNestedImpl extends NetworkPolicyFluentImpl> implements WatchEventFluent.NetworkPolicyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyBuilder builder;
    
            NetworkPolicyObjectNestedImpl(NetworkPolicy item){
                    this.builder = new NetworkPolicyBuilder(this, item);
            }
            NetworkPolicyObjectNestedImpl(){
                    this.builder = new NetworkPolicyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNetworkPolicyObject(builder.build());
    }
    public N endNetworkPolicyObject(){
            return and();
    }

}
    public class ContainerStateObjectNestedImpl extends ContainerStateFluentImpl> implements WatchEventFluent.ContainerStateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerStateBuilder builder;
    
            ContainerStateObjectNestedImpl(ContainerState item){
                    this.builder = new ContainerStateBuilder(this, item);
            }
            ContainerStateObjectNestedImpl(){
                    this.builder = new ContainerStateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerStateObject(builder.build());
    }
    public N endContainerStateObject(){
            return and();
    }

}
    public class APIVersionObjectNestedImpl extends APIVersionFluentImpl> implements WatchEventFluent.APIVersionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final APIVersionBuilder builder;
    
            APIVersionObjectNestedImpl(APIVersion item){
                    this.builder = new APIVersionBuilder(this, item);
            }
            APIVersionObjectNestedImpl(){
                    this.builder = new APIVersionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withAPIVersionObject(builder.build());
    }
    public N endAPIVersionObject(){
            return and();
    }

}
    public class ProjectNamespaceObjectNestedImpl extends ProjectNamespaceFluentImpl> implements WatchEventFluent.ProjectNamespaceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectNamespaceBuilder builder;
    
            ProjectNamespaceObjectNestedImpl(ProjectNamespace item){
                    this.builder = new ProjectNamespaceBuilder(this, item);
            }
            ProjectNamespaceObjectNestedImpl(){
                    this.builder = new ProjectNamespaceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectNamespaceObject(builder.build());
    }
    public N endProjectNamespaceObject(){
            return and();
    }

}
    public class ProjectSpecObjectNestedImpl extends ProjectSpecFluentImpl> implements WatchEventFluent.ProjectSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectSpecBuilder builder;
    
            ProjectSpecObjectNestedImpl(ProjectSpec item){
                    this.builder = new ProjectSpecBuilder(this, item);
            }
            ProjectSpecObjectNestedImpl(){
                    this.builder = new ProjectSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectSpecObject(builder.build());
    }
    public N endProjectSpecObject(){
            return and();
    }

}
    public class HTTPHeaderObjectNestedImpl extends HTTPHeaderFluentImpl> implements WatchEventFluent.HTTPHeaderObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HTTPHeaderBuilder builder;
    
            HTTPHeaderObjectNestedImpl(HTTPHeader item){
                    this.builder = new HTTPHeaderBuilder(this, item);
            }
            HTTPHeaderObjectNestedImpl(){
                    this.builder = new HTTPHeaderBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHTTPHeaderObject(builder.build());
    }
    public N endHTTPHeaderObject(){
            return and();
    }

}
    public class ServiceObjectNestedImpl extends ServiceFluentImpl> implements WatchEventFluent.ServiceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceBuilder builder;
    
            ServiceObjectNestedImpl(Service item){
                    this.builder = new ServiceBuilder(this, item);
            }
            ServiceObjectNestedImpl(){
                    this.builder = new ServiceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServiceObject(builder.build());
    }
    public N endServiceObject(){
            return and();
    }

}
    public class NetworkPolicyPortObjectNestedImpl extends NetworkPolicyPortFluentImpl> implements WatchEventFluent.NetworkPolicyPortObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NetworkPolicyPortBuilder builder;
    
            NetworkPolicyPortObjectNestedImpl(NetworkPolicyPort item){
                    this.builder = new NetworkPolicyPortBuilder(this, item);
            }
            NetworkPolicyPortObjectNestedImpl(){
                    this.builder = new NetworkPolicyPortBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNetworkPolicyPortObject(builder.build());
    }
    public N endNetworkPolicyPortObject(){
            return and();
    }

}
    public class IngressTLSObjectNestedImpl extends IngressTLSFluentImpl> implements WatchEventFluent.IngressTLSObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressTLSBuilder builder;
    
            IngressTLSObjectNestedImpl(IngressTLS item){
                    this.builder = new IngressTLSBuilder(this, item);
            }
            IngressTLSObjectNestedImpl(){
                    this.builder = new IngressTLSBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressTLSObject(builder.build());
    }
    public N endIngressTLSObject(){
            return and();
    }

}
    public class PipelineTemplateArgumentObjectNestedImpl extends PipelineTemplateArgumentFluentImpl> implements WatchEventFluent.PipelineTemplateArgumentObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateArgumentBuilder builder;
    
            PipelineTemplateArgumentObjectNestedImpl(PipelineTemplateArgument item){
                    this.builder = new PipelineTemplateArgumentBuilder(this, item);
            }
            PipelineTemplateArgumentObjectNestedImpl(){
                    this.builder = new PipelineTemplateArgumentBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateArgumentObject(builder.build());
    }
    public N endPipelineTemplateArgumentObject(){
            return and();
    }

}
    public class VolumeProjectionObjectNestedImpl extends VolumeProjectionFluentImpl> implements WatchEventFluent.VolumeProjectionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final VolumeProjectionBuilder builder;
    
            VolumeProjectionObjectNestedImpl(VolumeProjection item){
                    this.builder = new VolumeProjectionBuilder(this, item);
            }
            VolumeProjectionObjectNestedImpl(){
                    this.builder = new VolumeProjectionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withVolumeProjectionObject(builder.build());
    }
    public N endVolumeProjectionObject(){
            return and();
    }

}
    public class PersistentVolumeSpecObjectNestedImpl extends PersistentVolumeSpecFluentImpl> implements WatchEventFluent.PersistentVolumeSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeSpecBuilder builder;
    
            PersistentVolumeSpecObjectNestedImpl(PersistentVolumeSpec item){
                    this.builder = new PersistentVolumeSpecBuilder(this, item);
            }
            PersistentVolumeSpecObjectNestedImpl(){
                    this.builder = new PersistentVolumeSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeSpecObject(builder.build());
    }
    public N endPersistentVolumeSpecObject(){
            return and();
    }

}
    public class SecretEnvSourceObjectNestedImpl extends SecretEnvSourceFluentImpl> implements WatchEventFluent.SecretEnvSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretEnvSourceBuilder builder;
    
            SecretEnvSourceObjectNestedImpl(SecretEnvSource item){
                    this.builder = new SecretEnvSourceBuilder(this, item);
            }
            SecretEnvSourceObjectNestedImpl(){
                    this.builder = new SecretEnvSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretEnvSourceObject(builder.build());
    }
    public N endSecretEnvSourceObject(){
            return and();
    }

}
    public class NFSVolumeSourceObjectNestedImpl extends NFSVolumeSourceFluentImpl> implements WatchEventFluent.NFSVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NFSVolumeSourceBuilder builder;
    
            NFSVolumeSourceObjectNestedImpl(NFSVolumeSource item){
                    this.builder = new NFSVolumeSourceBuilder(this, item);
            }
            NFSVolumeSourceObjectNestedImpl(){
                    this.builder = new NFSVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNFSVolumeSourceObject(builder.build());
    }
    public N endNFSVolumeSourceObject(){
            return and();
    }

}
    public class EventObjectNestedImpl extends EventFluentImpl> implements WatchEventFluent.EventObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EventBuilder builder;
    
            EventObjectNestedImpl(Event item){
                    this.builder = new EventBuilder(this, item);
            }
            EventObjectNestedImpl(){
                    this.builder = new EventBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEventObject(builder.build());
    }
    public N endEventObject(){
            return and();
    }

}
    public class ObjectFieldSelectorObjectNestedImpl extends ObjectFieldSelectorFluentImpl> implements WatchEventFluent.ObjectFieldSelectorObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ObjectFieldSelectorBuilder builder;
    
            ObjectFieldSelectorObjectNestedImpl(ObjectFieldSelector item){
                    this.builder = new ObjectFieldSelectorBuilder(this, item);
            }
            ObjectFieldSelectorObjectNestedImpl(){
                    this.builder = new ObjectFieldSelectorBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withObjectFieldSelectorObject(builder.build());
    }
    public N endObjectFieldSelectorObject(){
            return and();
    }

}
    public class IngressSpecObjectNestedImpl extends IngressSpecFluentImpl> implements WatchEventFluent.IngressSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final IngressSpecBuilder builder;
    
            IngressSpecObjectNestedImpl(IngressSpec item){
                    this.builder = new IngressSpecBuilder(this, item);
            }
            IngressSpecObjectNestedImpl(){
                    this.builder = new IngressSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withIngressSpecObject(builder.build());
    }
    public N endIngressSpecObject(){
            return and();
    }

}
    public class NamespaceStatusObjectNestedImpl extends NamespaceStatusFluentImpl> implements WatchEventFluent.NamespaceStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceStatusBuilder builder;
    
            NamespaceStatusObjectNestedImpl(NamespaceStatus item){
                    this.builder = new NamespaceStatusBuilder(this, item);
            }
            NamespaceStatusObjectNestedImpl(){
                    this.builder = new NamespaceStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamespaceStatusObject(builder.build());
    }
    public N endNamespaceStatusObject(){
            return and();
    }

}
    public class SecurityContextObjectNestedImpl extends SecurityContextFluentImpl> implements WatchEventFluent.SecurityContextObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecurityContextBuilder builder;
    
            SecurityContextObjectNestedImpl(SecurityContext item){
                    this.builder = new SecurityContextBuilder(this, item);
            }
            SecurityContextObjectNestedImpl(){
                    this.builder = new SecurityContextBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecurityContextObject(builder.build());
    }
    public N endSecurityContextObject(){
            return and();
    }

}
    public class JenkinsBindingStatusObjectNestedImpl extends JenkinsBindingStatusFluentImpl> implements WatchEventFluent.JenkinsBindingStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBindingStatusBuilder builder;
    
            JenkinsBindingStatusObjectNestedImpl(JenkinsBindingStatus item){
                    this.builder = new JenkinsBindingStatusBuilder(this, item);
            }
            JenkinsBindingStatusObjectNestedImpl(){
                    this.builder = new JenkinsBindingStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsBindingStatusObject(builder.build());
    }
    public N endJenkinsBindingStatusObject(){
            return and();
    }

}
    public class PodDisruptionBudgetSpecObjectNestedImpl extends PodDisruptionBudgetSpecFluentImpl> implements WatchEventFluent.PodDisruptionBudgetSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetSpecBuilder builder;
    
            PodDisruptionBudgetSpecObjectNestedImpl(PodDisruptionBudgetSpec item){
                    this.builder = new PodDisruptionBudgetSpecBuilder(this, item);
            }
            PodDisruptionBudgetSpecObjectNestedImpl(){
                    this.builder = new PodDisruptionBudgetSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodDisruptionBudgetSpecObject(builder.build());
    }
    public N endPodDisruptionBudgetSpecObject(){
            return and();
    }

}
    public class CodeRepositoryListObjectNestedImpl extends CodeRepositoryListFluentImpl> implements WatchEventFluent.CodeRepositoryListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryListBuilder builder;
    
            CodeRepositoryListObjectNestedImpl(CodeRepositoryList item){
                    this.builder = new CodeRepositoryListBuilder(this, item);
            }
            CodeRepositoryListObjectNestedImpl(){
                    this.builder = new CodeRepositoryListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositoryListObject(builder.build());
    }
    public N endCodeRepositoryListObject(){
            return and();
    }

}
    public class TaintObjectNestedImpl extends TaintFluentImpl> implements WatchEventFluent.TaintObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final TaintBuilder builder;
    
            TaintObjectNestedImpl(Taint item){
                    this.builder = new TaintBuilder(this, item);
            }
            TaintObjectNestedImpl(){
                    this.builder = new TaintBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withTaintObject(builder.build());
    }
    public N endTaintObject(){
            return and();
    }

}
    public class PodSecurityPolicySpecObjectNestedImpl extends PodSecurityPolicySpecFluentImpl> implements WatchEventFluent.PodSecurityPolicySpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodSecurityPolicySpecBuilder builder;
    
            PodSecurityPolicySpecObjectNestedImpl(PodSecurityPolicySpec item){
                    this.builder = new PodSecurityPolicySpecBuilder(this, item);
            }
            PodSecurityPolicySpecObjectNestedImpl(){
                    this.builder = new PodSecurityPolicySpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodSecurityPolicySpecObject(builder.build());
    }
    public N endPodSecurityPolicySpecObject(){
            return and();
    }

}
    public class CustomResourceDefinitionNamesObjectNestedImpl extends CustomResourceDefinitionNamesFluentImpl> implements WatchEventFluent.CustomResourceDefinitionNamesObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CustomResourceDefinitionNamesBuilder builder;
    
            CustomResourceDefinitionNamesObjectNestedImpl(CustomResourceDefinitionNames item){
                    this.builder = new CustomResourceDefinitionNamesBuilder(this, item);
            }
            CustomResourceDefinitionNamesObjectNestedImpl(){
                    this.builder = new CustomResourceDefinitionNamesBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCustomResourceDefinitionNamesObject(builder.build());
    }
    public N endCustomResourceDefinitionNamesObject(){
            return and();
    }

}
    public class NodeObjectNestedImpl extends NodeFluentImpl> implements WatchEventFluent.NodeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeBuilder builder;
    
            NodeObjectNestedImpl(Node item){
                    this.builder = new NodeBuilder(this, item);
            }
            NodeObjectNestedImpl(){
                    this.builder = new NodeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeObject(builder.build());
    }
    public N endNodeObject(){
            return and();
    }

}
    public class InfoObjectNestedImpl extends InfoFluentImpl> implements WatchEventFluent.InfoObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final InfoBuilder builder;
    
            InfoObjectNestedImpl(Info item){
                    this.builder = new InfoBuilder(this, item);
            }
            InfoObjectNestedImpl(){
                    this.builder = new InfoBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withInfoObject(builder.build());
    }
    public N endInfoObject(){
            return and();
    }

}
    public class TCPSocketActionObjectNestedImpl extends TCPSocketActionFluentImpl> implements WatchEventFluent.TCPSocketActionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final TCPSocketActionBuilder builder;
    
            TCPSocketActionObjectNestedImpl(TCPSocketAction item){
                    this.builder = new TCPSocketActionBuilder(this, item);
            }
            TCPSocketActionObjectNestedImpl(){
                    this.builder = new TCPSocketActionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withTCPSocketActionObject(builder.build());
    }
    public N endTCPSocketActionObject(){
            return and();
    }

}
    public class EnvFromSourceObjectNestedImpl extends EnvFromSourceFluentImpl> implements WatchEventFluent.EnvFromSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EnvFromSourceBuilder builder;
    
            EnvFromSourceObjectNestedImpl(EnvFromSource item){
                    this.builder = new EnvFromSourceBuilder(this, item);
            }
            EnvFromSourceObjectNestedImpl(){
                    this.builder = new EnvFromSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEnvFromSourceObject(builder.build());
    }
    public N endEnvFromSourceObject(){
            return and();
    }

}
    public class KeyToPathObjectNestedImpl extends KeyToPathFluentImpl> implements WatchEventFluent.KeyToPathObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final KeyToPathBuilder builder;
    
            KeyToPathObjectNestedImpl(KeyToPath item){
                    this.builder = new KeyToPathBuilder(this, item);
            }
            KeyToPathObjectNestedImpl(){
                    this.builder = new KeyToPathBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withKeyToPathObject(builder.build());
    }
    public N endKeyToPathObject(){
            return and();
    }

}
    public class ReplicaSetObjectNestedImpl extends ReplicaSetFluentImpl> implements WatchEventFluent.ReplicaSetObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetBuilder builder;
    
            ReplicaSetObjectNestedImpl(ReplicaSet item){
                    this.builder = new ReplicaSetBuilder(this, item);
            }
            ReplicaSetObjectNestedImpl(){
                    this.builder = new ReplicaSetBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicaSetObject(builder.build());
    }
    public N endReplicaSetObject(){
            return and();
    }

}
    public class NodeSelectorTermObjectNestedImpl extends NodeSelectorTermFluentImpl> implements WatchEventFluent.NodeSelectorTermObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeSelectorTermBuilder builder;
    
            NodeSelectorTermObjectNestedImpl(NodeSelectorTerm item){
                    this.builder = new NodeSelectorTermBuilder(this, item);
            }
            NodeSelectorTermObjectNestedImpl(){
                    this.builder = new NodeSelectorTermBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeSelectorTermObject(builder.build());
    }
    public N endNodeSelectorTermObject(){
            return and();
    }

}
    public class SubjectAccessReviewStatusObjectNestedImpl extends SubjectAccessReviewStatusFluentImpl> implements WatchEventFluent.SubjectAccessReviewStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SubjectAccessReviewStatusBuilder builder;
    
            SubjectAccessReviewStatusObjectNestedImpl(SubjectAccessReviewStatus item){
                    this.builder = new SubjectAccessReviewStatusBuilder(this, item);
            }
            SubjectAccessReviewStatusObjectNestedImpl(){
                    this.builder = new SubjectAccessReviewStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSubjectAccessReviewStatusObject(builder.build());
    }
    public N endSubjectAccessReviewStatusObject(){
            return and();
    }

}
    public class DeploymentListObjectNestedImpl extends DeploymentListFluentImpl> implements WatchEventFluent.DeploymentListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentListBuilder builder;
    
            DeploymentListObjectNestedImpl(DeploymentList item){
                    this.builder = new DeploymentListBuilder(this, item);
            }
            DeploymentListObjectNestedImpl(){
                    this.builder = new DeploymentListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentListObject(builder.build());
    }
    public N endDeploymentListObject(){
            return and();
    }

}
    public class PersistentVolumeClaimSpecObjectNestedImpl extends PersistentVolumeClaimSpecFluentImpl> implements WatchEventFluent.PersistentVolumeClaimSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimSpecBuilder builder;
    
            PersistentVolumeClaimSpecObjectNestedImpl(PersistentVolumeClaimSpec item){
                    this.builder = new PersistentVolumeClaimSpecBuilder(this, item);
            }
            PersistentVolumeClaimSpecObjectNestedImpl(){
                    this.builder = new PersistentVolumeClaimSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeClaimSpecObject(builder.build());
    }
    public N endPersistentVolumeClaimSpecObject(){
            return and();
    }

}
    public class NamespaceSpecObjectNestedImpl extends NamespaceSpecFluentImpl> implements WatchEventFluent.NamespaceSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamespaceSpecBuilder builder;
    
            NamespaceSpecObjectNestedImpl(NamespaceSpec item){
                    this.builder = new NamespaceSpecBuilder(this, item);
            }
            NamespaceSpecObjectNestedImpl(){
                    this.builder = new NamespaceSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamespaceSpecObject(builder.build());
    }
    public N endNamespaceSpecObject(){
            return and();
    }

}
    public class PipelineTaskArgumentDisplayObjectNestedImpl extends PipelineTaskArgumentDisplayFluentImpl> implements WatchEventFluent.PipelineTaskArgumentDisplayObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentDisplayBuilder builder;
    
            PipelineTaskArgumentDisplayObjectNestedImpl(PipelineTaskArgumentDisplay item){
                    this.builder = new PipelineTaskArgumentDisplayBuilder(this, item);
            }
            PipelineTaskArgumentDisplayObjectNestedImpl(){
                    this.builder = new PipelineTaskArgumentDisplayBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskArgumentDisplayObject(builder.build());
    }
    public N endPipelineTaskArgumentDisplayObject(){
            return and();
    }

}
    public class EndpointSubsetObjectNestedImpl extends EndpointSubsetFluentImpl> implements WatchEventFluent.EndpointSubsetObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointSubsetBuilder builder;
    
            EndpointSubsetObjectNestedImpl(EndpointSubset item){
                    this.builder = new EndpointSubsetBuilder(this, item);
            }
            EndpointSubsetObjectNestedImpl(){
                    this.builder = new EndpointSubsetBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEndpointSubsetObject(builder.build());
    }
    public N endEndpointSubsetObject(){
            return and();
    }

}
    public class PatchObjectNestedImpl extends PatchFluentImpl> implements WatchEventFluent.PatchObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PatchBuilder builder;
    
            PatchObjectNestedImpl(Patch item){
                    this.builder = new PatchBuilder(this, item);
            }
            PatchObjectNestedImpl(){
                    this.builder = new PatchBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPatchObject(builder.build());
    }
    public N endPatchObject(){
            return and();
    }

}
    public class JobTemplateSpecObjectNestedImpl extends JobTemplateSpecFluentImpl> implements WatchEventFluent.JobTemplateSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobTemplateSpecBuilder builder;
    
            JobTemplateSpecObjectNestedImpl(JobTemplateSpec item){
                    this.builder = new JobTemplateSpecBuilder(this, item);
            }
            JobTemplateSpecObjectNestedImpl(){
                    this.builder = new JobTemplateSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJobTemplateSpecObject(builder.build());
    }
    public N endJobTemplateSpecObject(){
            return and();
    }

}
    public class LoadBalancerStatusObjectNestedImpl extends LoadBalancerStatusFluentImpl> implements WatchEventFluent.LoadBalancerStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LoadBalancerStatusBuilder builder;
    
            LoadBalancerStatusObjectNestedImpl(LoadBalancerStatus item){
                    this.builder = new LoadBalancerStatusBuilder(this, item);
            }
            LoadBalancerStatusObjectNestedImpl(){
                    this.builder = new LoadBalancerStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLoadBalancerStatusObject(builder.build());
    }
    public N endLoadBalancerStatusObject(){
            return and();
    }

}
    public class ReplicaSetStatusObjectNestedImpl extends ReplicaSetStatusFluentImpl> implements WatchEventFluent.ReplicaSetStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetStatusBuilder builder;
    
            ReplicaSetStatusObjectNestedImpl(ReplicaSetStatus item){
                    this.builder = new ReplicaSetStatusBuilder(this, item);
            }
            ReplicaSetStatusObjectNestedImpl(){
                    this.builder = new ReplicaSetStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicaSetStatusObject(builder.build());
    }
    public N endReplicaSetStatusObject(){
            return and();
    }

}
    public class ClusterPipelineTemplateObjectNestedImpl extends ClusterPipelineTemplateFluentImpl> implements WatchEventFluent.ClusterPipelineTemplateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPipelineTemplateBuilder builder;
    
            ClusterPipelineTemplateObjectNestedImpl(ClusterPipelineTemplate item){
                    this.builder = new ClusterPipelineTemplateBuilder(this, item);
            }
            ClusterPipelineTemplateObjectNestedImpl(){
                    this.builder = new ClusterPipelineTemplateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withClusterPipelineTemplateObject(builder.build());
    }
    public N endClusterPipelineTemplateObject(){
            return and();
    }

}
    public class PipelineConfigTemplateSpecObjectNestedImpl extends PipelineConfigTemplateSpecFluentImpl> implements WatchEventFluent.PipelineConfigTemplateSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineConfigTemplateSpecBuilder builder;
    
            PipelineConfigTemplateSpecObjectNestedImpl(PipelineConfigTemplateSpec item){
                    this.builder = new PipelineConfigTemplateSpecBuilder(this, item);
            }
            PipelineConfigTemplateSpecObjectNestedImpl(){
                    this.builder = new PipelineConfigTemplateSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineConfigTemplateSpecObject(builder.build());
    }
    public N endPipelineConfigTemplateSpecObject(){
            return and();
    }

}
    public class DaemonSetListObjectNestedImpl extends DaemonSetListFluentImpl> implements WatchEventFluent.DaemonSetListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetListBuilder builder;
    
            DaemonSetListObjectNestedImpl(DaemonSetList item){
                    this.builder = new DaemonSetListBuilder(this, item);
            }
            DaemonSetListObjectNestedImpl(){
                    this.builder = new DaemonSetListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDaemonSetListObject(builder.build());
    }
    public N endDaemonSetListObject(){
            return and();
    }

}
    public class HorizontalPodAutoscalerStatusObjectNestedImpl extends HorizontalPodAutoscalerStatusFluentImpl> implements WatchEventFluent.HorizontalPodAutoscalerStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HorizontalPodAutoscalerStatusBuilder builder;
    
            HorizontalPodAutoscalerStatusObjectNestedImpl(HorizontalPodAutoscalerStatus item){
                    this.builder = new HorizontalPodAutoscalerStatusBuilder(this, item);
            }
            HorizontalPodAutoscalerStatusObjectNestedImpl(){
                    this.builder = new HorizontalPodAutoscalerStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHorizontalPodAutoscalerStatusObject(builder.build());
    }
    public N endHorizontalPodAutoscalerStatusObject(){
            return and();
    }

}
    public class SubjectAccessReviewSpecObjectNestedImpl extends SubjectAccessReviewSpecFluentImpl> implements WatchEventFluent.SubjectAccessReviewSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SubjectAccessReviewSpecBuilder builder;
    
            SubjectAccessReviewSpecObjectNestedImpl(SubjectAccessReviewSpec item){
                    this.builder = new SubjectAccessReviewSpecBuilder(this, item);
            }
            SubjectAccessReviewSpecObjectNestedImpl(){
                    this.builder = new SubjectAccessReviewSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSubjectAccessReviewSpecObject(builder.build());
    }
    public N endSubjectAccessReviewSpecObject(){
            return and();
    }

}
    public class LifecycleObjectNestedImpl extends LifecycleFluentImpl> implements WatchEventFluent.LifecycleObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final LifecycleBuilder builder;
    
            LifecycleObjectNestedImpl(Lifecycle item){
                    this.builder = new LifecycleBuilder(this, item);
            }
            LifecycleObjectNestedImpl(){
                    this.builder = new LifecycleBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withLifecycleObject(builder.build());
    }
    public N endLifecycleObject(){
            return and();
    }

}
    public class JobObjectNestedImpl extends JobFluentImpl> implements WatchEventFluent.JobObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobBuilder builder;
    
            JobObjectNestedImpl(Job item){
                    this.builder = new JobBuilder(this, item);
            }
            JobObjectNestedImpl(){
                    this.builder = new JobBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJobObject(builder.build());
    }
    public N endJobObject(){
            return and();
    }

}
    public class NamedAuthInfoObjectNestedImpl extends NamedAuthInfoFluentImpl> implements WatchEventFluent.NamedAuthInfoObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NamedAuthInfoBuilder builder;
    
            NamedAuthInfoObjectNestedImpl(NamedAuthInfo item){
                    this.builder = new NamedAuthInfoBuilder(this, item);
            }
            NamedAuthInfoObjectNestedImpl(){
                    this.builder = new NamedAuthInfoBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNamedAuthInfoObject(builder.build());
    }
    public N endNamedAuthInfoObject(){
            return and();
    }

}
    public class ContainerImageObjectNestedImpl extends ContainerImageFluentImpl> implements WatchEventFluent.ContainerImageObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerImageBuilder builder;
    
            ContainerImageObjectNestedImpl(ContainerImage item){
                    this.builder = new ContainerImageBuilder(this, item);
            }
            ContainerImageObjectNestedImpl(){
                    this.builder = new ContainerImageBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerImageObject(builder.build());
    }
    public N endContainerImageObject(){
            return and();
    }

}
    public class StatefulSetUpdateStrategyObjectNestedImpl extends StatefulSetUpdateStrategyFluentImpl> implements WatchEventFluent.StatefulSetUpdateStrategyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetUpdateStrategyBuilder builder;
    
            StatefulSetUpdateStrategyObjectNestedImpl(StatefulSetUpdateStrategy item){
                    this.builder = new StatefulSetUpdateStrategyBuilder(this, item);
            }
            StatefulSetUpdateStrategyObjectNestedImpl(){
                    this.builder = new StatefulSetUpdateStrategyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatefulSetUpdateStrategyObject(builder.build());
    }
    public N endStatefulSetUpdateStrategyObject(){
            return and();
    }

}
    public class PipelineTriggerCronObjectNestedImpl extends PipelineTriggerCronFluentImpl> implements WatchEventFluent.PipelineTriggerCronObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTriggerCronBuilder builder;
    
            PipelineTriggerCronObjectNestedImpl(PipelineTriggerCron item){
                    this.builder = new PipelineTriggerCronBuilder(this, item);
            }
            PipelineTriggerCronObjectNestedImpl(){
                    this.builder = new PipelineTriggerCronBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTriggerCronObject(builder.build());
    }
    public N endPipelineTriggerCronObject(){
            return and();
    }

}
    public class NonResourceAttributesObjectNestedImpl extends NonResourceAttributesFluentImpl> implements WatchEventFluent.NonResourceAttributesObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NonResourceAttributesBuilder builder;
    
            NonResourceAttributesObjectNestedImpl(NonResourceAttributes item){
                    this.builder = new NonResourceAttributesBuilder(this, item);
            }
            NonResourceAttributesObjectNestedImpl(){
                    this.builder = new NonResourceAttributesBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNonResourceAttributesObject(builder.build());
    }
    public N endNonResourceAttributesObject(){
            return and();
    }

}
    public class ObjectMetaObjectNestedImpl extends ObjectMetaFluentImpl> implements WatchEventFluent.ObjectMetaObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ObjectMetaBuilder builder;
    
            ObjectMetaObjectNestedImpl(ObjectMeta item){
                    this.builder = new ObjectMetaBuilder(this, item);
            }
            ObjectMetaObjectNestedImpl(){
                    this.builder = new ObjectMetaBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withObjectMetaObject(builder.build());
    }
    public N endObjectMetaObject(){
            return and();
    }

}
    public class EnvVarSourceObjectNestedImpl extends EnvVarSourceFluentImpl> implements WatchEventFluent.EnvVarSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EnvVarSourceBuilder builder;
    
            EnvVarSourceObjectNestedImpl(EnvVarSource item){
                    this.builder = new EnvVarSourceBuilder(this, item);
            }
            EnvVarSourceObjectNestedImpl(){
                    this.builder = new EnvVarSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEnvVarSourceObject(builder.build());
    }
    public N endEnvVarSourceObject(){
            return and();
    }

}
    public class RollingUpdateDaemonSetObjectNestedImpl extends RollingUpdateDaemonSetFluentImpl> implements WatchEventFluent.RollingUpdateDaemonSetObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RollingUpdateDaemonSetBuilder builder;
    
            RollingUpdateDaemonSetObjectNestedImpl(RollingUpdateDaemonSet item){
                    this.builder = new RollingUpdateDaemonSetBuilder(this, item);
            }
            RollingUpdateDaemonSetObjectNestedImpl(){
                    this.builder = new RollingUpdateDaemonSetBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRollingUpdateDaemonSetObject(builder.build());
    }
    public N endRollingUpdateDaemonSetObject(){
            return and();
    }

}
    public class PhotonPersistentDiskVolumeSourceObjectNestedImpl extends PhotonPersistentDiskVolumeSourceFluentImpl> implements WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PhotonPersistentDiskVolumeSourceBuilder builder;
    
            PhotonPersistentDiskVolumeSourceObjectNestedImpl(PhotonPersistentDiskVolumeSource item){
                    this.builder = new PhotonPersistentDiskVolumeSourceBuilder(this, item);
            }
            PhotonPersistentDiskVolumeSourceObjectNestedImpl(){
                    this.builder = new PhotonPersistentDiskVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPhotonPersistentDiskVolumeSourceObject(builder.build());
    }
    public N endPhotonPersistentDiskVolumeSourceObject(){
            return and();
    }

}
    public class ReplicationControllerListObjectNestedImpl extends ReplicationControllerListFluentImpl> implements WatchEventFluent.ReplicationControllerListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicationControllerListBuilder builder;
    
            ReplicationControllerListObjectNestedImpl(ReplicationControllerList item){
                    this.builder = new ReplicationControllerListBuilder(this, item);
            }
            ReplicationControllerListObjectNestedImpl(){
                    this.builder = new ReplicationControllerListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicationControllerListObject(builder.build());
    }
    public N endReplicationControllerListObject(){
            return and();
    }

}
    public class HTTPIngressPathObjectNestedImpl extends HTTPIngressPathFluentImpl> implements WatchEventFluent.HTTPIngressPathObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HTTPIngressPathBuilder builder;
    
            HTTPIngressPathObjectNestedImpl(HTTPIngressPath item){
                    this.builder = new HTTPIngressPathBuilder(this, item);
            }
            HTTPIngressPathObjectNestedImpl(){
                    this.builder = new HTTPIngressPathBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHTTPIngressPathObject(builder.build());
    }
    public N endHTTPIngressPathObject(){
            return and();
    }

}
    public class JobStatusObjectNestedImpl extends JobStatusFluentImpl> implements WatchEventFluent.JobStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobStatusBuilder builder;
    
            JobStatusObjectNestedImpl(JobStatus item){
                    this.builder = new JobStatusBuilder(this, item);
            }
            JobStatusObjectNestedImpl(){
                    this.builder = new JobStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJobStatusObject(builder.build());
    }
    public N endJobStatusObject(){
            return and();
    }

}
    public class DownwardAPIVolumeFileObjectNestedImpl extends DownwardAPIVolumeFileFluentImpl> implements WatchEventFluent.DownwardAPIVolumeFileObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DownwardAPIVolumeFileBuilder builder;
    
            DownwardAPIVolumeFileObjectNestedImpl(DownwardAPIVolumeFile item){
                    this.builder = new DownwardAPIVolumeFileBuilder(this, item);
            }
            DownwardAPIVolumeFileObjectNestedImpl(){
                    this.builder = new DownwardAPIVolumeFileBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDownwardAPIVolumeFileObject(builder.build());
    }
    public N endDownwardAPIVolumeFileObject(){
            return and();
    }

}
    public class RollbackConfigObjectNestedImpl extends RollbackConfigFluentImpl> implements WatchEventFluent.RollbackConfigObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RollbackConfigBuilder builder;
    
            RollbackConfigObjectNestedImpl(RollbackConfig item){
                    this.builder = new RollbackConfigBuilder(this, item);
            }
            RollbackConfigObjectNestedImpl(){
                    this.builder = new RollbackConfigBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRollbackConfigObject(builder.build());
    }
    public N endRollbackConfigObject(){
            return and();
    }

}
    public class CapabilitiesObjectNestedImpl extends CapabilitiesFluentImpl> implements WatchEventFluent.CapabilitiesObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CapabilitiesBuilder builder;
    
            CapabilitiesObjectNestedImpl(Capabilities item){
                    this.builder = new CapabilitiesBuilder(this, item);
            }
            CapabilitiesObjectNestedImpl(){
                    this.builder = new CapabilitiesBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCapabilitiesObject(builder.build());
    }
    public N endCapabilitiesObject(){
            return and();
    }

}
    public class PodAffinityObjectNestedImpl extends PodAffinityFluentImpl> implements WatchEventFluent.PodAffinityObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodAffinityBuilder builder;
    
            PodAffinityObjectNestedImpl(PodAffinity item){
                    this.builder = new PodAffinityBuilder(this, item);
            }
            PodAffinityObjectNestedImpl(){
                    this.builder = new PodAffinityBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodAffinityObject(builder.build());
    }
    public N endPodAffinityObject(){
            return and();
    }

}
    public class ServiceSpecObjectNestedImpl extends ServiceSpecFluentImpl> implements WatchEventFluent.ServiceSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ServiceSpecBuilder builder;
    
            ServiceSpecObjectNestedImpl(ServiceSpec item){
                    this.builder = new ServiceSpecBuilder(this, item);
            }
            ServiceSpecObjectNestedImpl(){
                    this.builder = new ServiceSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withServiceSpecObject(builder.build());
    }
    public N endServiceSpecObject(){
            return and();
    }

}
    public class ResourceQuotaStatusObjectNestedImpl extends ResourceQuotaStatusFluentImpl> implements WatchEventFluent.ResourceQuotaStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ResourceQuotaStatusBuilder builder;
    
            ResourceQuotaStatusObjectNestedImpl(ResourceQuotaStatus item){
                    this.builder = new ResourceQuotaStatusBuilder(this, item);
            }
            ResourceQuotaStatusObjectNestedImpl(){
                    this.builder = new ResourceQuotaStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withResourceQuotaStatusObject(builder.build());
    }
    public N endResourceQuotaStatusObject(){
            return and();
    }

}
    public class ClusterPipelineTaskTemplateObjectNestedImpl extends ClusterPipelineTaskTemplateFluentImpl> implements WatchEventFluent.ClusterPipelineTaskTemplateObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ClusterPipelineTaskTemplateBuilder builder;
    
            ClusterPipelineTaskTemplateObjectNestedImpl(ClusterPipelineTaskTemplate item){
                    this.builder = new ClusterPipelineTaskTemplateBuilder(this, item);
            }
            ClusterPipelineTaskTemplateObjectNestedImpl(){
                    this.builder = new ClusterPipelineTaskTemplateBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withClusterPipelineTaskTemplateObject(builder.build());
    }
    public N endClusterPipelineTaskTemplateObject(){
            return and();
    }

}
    public class ReplicaSetListObjectNestedImpl extends ReplicaSetListFluentImpl> implements WatchEventFluent.ReplicaSetListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ReplicaSetListBuilder builder;
    
            ReplicaSetListObjectNestedImpl(ReplicaSetList item){
                    this.builder = new ReplicaSetListBuilder(this, item);
            }
            ReplicaSetListObjectNestedImpl(){
                    this.builder = new ReplicaSetListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withReplicaSetListObject(builder.build());
    }
    public N endReplicaSetListObject(){
            return and();
    }

}
    public class StatefulSetSpecObjectNestedImpl extends StatefulSetSpecFluentImpl> implements WatchEventFluent.StatefulSetSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatefulSetSpecBuilder builder;
    
            StatefulSetSpecObjectNestedImpl(StatefulSetSpec item){
                    this.builder = new StatefulSetSpecBuilder(this, item);
            }
            StatefulSetSpecObjectNestedImpl(){
                    this.builder = new StatefulSetSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatefulSetSpecObject(builder.build());
    }
    public N endStatefulSetSpecObject(){
            return and();
    }

}
    public class SecretProjectionObjectNestedImpl extends SecretProjectionFluentImpl> implements WatchEventFluent.SecretProjectionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final SecretProjectionBuilder builder;
    
            SecretProjectionObjectNestedImpl(SecretProjection item){
                    this.builder = new SecretProjectionBuilder(this, item);
            }
            SecretProjectionObjectNestedImpl(){
                    this.builder = new SecretProjectionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withSecretProjectionObject(builder.build());
    }
    public N endSecretProjectionObject(){
            return and();
    }

}
    public class DeploymentObjectNestedImpl extends DeploymentFluentImpl> implements WatchEventFluent.DeploymentObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentBuilder builder;
    
            DeploymentObjectNestedImpl(Deployment item){
                    this.builder = new DeploymentBuilder(this, item);
            }
            DeploymentObjectNestedImpl(){
                    this.builder = new DeploymentBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentObject(builder.build());
    }
    public N endDeploymentObject(){
            return and();
    }

}
    public class JobConditionObjectNestedImpl extends JobConditionFluentImpl> implements WatchEventFluent.JobConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JobConditionBuilder builder;
    
            JobConditionObjectNestedImpl(JobCondition item){
                    this.builder = new JobConditionBuilder(this, item);
            }
            JobConditionObjectNestedImpl(){
                    this.builder = new JobConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJobConditionObject(builder.build());
    }
    public N endJobConditionObject(){
            return and();
    }

}
    public class PersistentVolumeClaimVolumeSourceObjectNestedImpl extends PersistentVolumeClaimVolumeSourceFluentImpl> implements WatchEventFluent.PersistentVolumeClaimVolumeSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeClaimVolumeSourceBuilder builder;
    
            PersistentVolumeClaimVolumeSourceObjectNestedImpl(PersistentVolumeClaimVolumeSource item){
                    this.builder = new PersistentVolumeClaimVolumeSourceBuilder(this, item);
            }
            PersistentVolumeClaimVolumeSourceObjectNestedImpl(){
                    this.builder = new PersistentVolumeClaimVolumeSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeClaimVolumeSourceObject(builder.build());
    }
    public N endPersistentVolumeClaimVolumeSourceObject(){
            return and();
    }

}
    public class JenkinsObjectNestedImpl extends JenkinsFluentImpl> implements WatchEventFluent.JenkinsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsBuilder builder;
    
            JenkinsObjectNestedImpl(Jenkins item){
                    this.builder = new JenkinsBuilder(this, item);
            }
            JenkinsObjectNestedImpl(){
                    this.builder = new JenkinsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withJenkinsObject(builder.build());
    }
    public N endJenkinsObject(){
            return and();
    }

}
    public class DeploymentStrategyObjectNestedImpl extends DeploymentStrategyFluentImpl> implements WatchEventFluent.DeploymentStrategyObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DeploymentStrategyBuilder builder;
    
            DeploymentStrategyObjectNestedImpl(DeploymentStrategy item){
                    this.builder = new DeploymentStrategyBuilder(this, item);
            }
            DeploymentStrategyObjectNestedImpl(){
                    this.builder = new DeploymentStrategyBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDeploymentStrategyObject(builder.build());
    }
    public N endDeploymentStrategyObject(){
            return and();
    }

}
    public class ContainerPortObjectNestedImpl extends ContainerPortFluentImpl> implements WatchEventFluent.ContainerPortObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ContainerPortBuilder builder;
    
            ContainerPortObjectNestedImpl(ContainerPort item){
                    this.builder = new ContainerPortBuilder(this, item);
            }
            ContainerPortObjectNestedImpl(){
                    this.builder = new ContainerPortBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withContainerPortObject(builder.build());
    }
    public N endContainerPortObject(){
            return and();
    }

}
    public class NodeAddressObjectNestedImpl extends NodeAddressFluentImpl> implements WatchEventFluent.NodeAddressObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeAddressBuilder builder;
    
            NodeAddressObjectNestedImpl(NodeAddress item){
                    this.builder = new NodeAddressBuilder(this, item);
            }
            NodeAddressObjectNestedImpl(){
                    this.builder = new NodeAddressBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeAddressObject(builder.build());
    }
    public N endNodeAddressObject(){
            return and();
    }

}
    public class PodTemplateListObjectNestedImpl extends PodTemplateListFluentImpl> implements WatchEventFluent.PodTemplateListObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodTemplateListBuilder builder;
    
            PodTemplateListObjectNestedImpl(PodTemplateList item){
                    this.builder = new PodTemplateListBuilder(this, item);
            }
            PodTemplateListObjectNestedImpl(){
                    this.builder = new PodTemplateListBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodTemplateListObject(builder.build());
    }
    public N endPodTemplateListObject(){
            return and();
    }

}
    public class PersistentVolumeStatusObjectNestedImpl extends PersistentVolumeStatusFluentImpl> implements WatchEventFluent.PersistentVolumeStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeStatusBuilder builder;
    
            PersistentVolumeStatusObjectNestedImpl(PersistentVolumeStatus item){
                    this.builder = new PersistentVolumeStatusBuilder(this, item);
            }
            PersistentVolumeStatusObjectNestedImpl(){
                    this.builder = new PersistentVolumeStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeStatusObject(builder.build());
    }
    public N endPersistentVolumeStatusObject(){
            return and();
    }

}
    public class DaemonSetObjectNestedImpl extends DaemonSetFluentImpl> implements WatchEventFluent.DaemonSetObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final DaemonSetBuilder builder;
    
            DaemonSetObjectNestedImpl(DaemonSet item){
                    this.builder = new DaemonSetBuilder(this, item);
            }
            DaemonSetObjectNestedImpl(){
                    this.builder = new DaemonSetBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withDaemonSetObject(builder.build());
    }
    public N endDaemonSetObject(){
            return and();
    }

}
    public class PodDisruptionBudgetObjectNestedImpl extends PodDisruptionBudgetFluentImpl> implements WatchEventFluent.PodDisruptionBudgetObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PodDisruptionBudgetBuilder builder;
    
            PodDisruptionBudgetObjectNestedImpl(PodDisruptionBudget item){
                    this.builder = new PodDisruptionBudgetBuilder(this, item);
            }
            PodDisruptionBudgetObjectNestedImpl(){
                    this.builder = new PodDisruptionBudgetBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPodDisruptionBudgetObject(builder.build());
    }
    public N endPodDisruptionBudgetObject(){
            return and();
    }

}
    public class PipelineTaskArgumentActionObjectNestedImpl extends PipelineTaskArgumentActionFluentImpl> implements WatchEventFluent.PipelineTaskArgumentActionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentActionBuilder builder;
    
            PipelineTaskArgumentActionObjectNestedImpl(PipelineTaskArgumentAction item){
                    this.builder = new PipelineTaskArgumentActionBuilder(this, item);
            }
            PipelineTaskArgumentActionObjectNestedImpl(){
                    this.builder = new PipelineTaskArgumentActionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskArgumentActionObject(builder.build());
    }
    public N endPipelineTaskArgumentActionObject(){
            return and();
    }

}
    public class ProjectStatusObjectNestedImpl extends ProjectStatusFluentImpl> implements WatchEventFluent.ProjectStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectStatusBuilder builder;
    
            ProjectStatusObjectNestedImpl(ProjectStatus item){
                    this.builder = new ProjectStatusBuilder(this, item);
            }
            ProjectStatusObjectNestedImpl(){
                    this.builder = new ProjectStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectStatusObject(builder.build());
    }
    public N endProjectStatusObject(){
            return and();
    }

}
    public class PipelineSpecObjectNestedImpl extends PipelineSpecFluentImpl> implements WatchEventFluent.PipelineSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineSpecBuilder builder;
    
            PipelineSpecObjectNestedImpl(PipelineSpec item){
                    this.builder = new PipelineSpecBuilder(this, item);
            }
            PipelineSpecObjectNestedImpl(){
                    this.builder = new PipelineSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineSpecObject(builder.build());
    }
    public N endPipelineSpecObject(){
            return and();
    }

}
    public class ScaleStatusObjectNestedImpl extends ScaleStatusFluentImpl> implements WatchEventFluent.ScaleStatusObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ScaleStatusBuilder builder;
    
            ScaleStatusObjectNestedImpl(ScaleStatus item){
                    this.builder = new ScaleStatusBuilder(this, item);
            }
            ScaleStatusObjectNestedImpl(){
                    this.builder = new ScaleStatusBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withScaleStatusObject(builder.build());
    }
    public N endScaleStatusObject(){
            return and();
    }

}
    public class ProjectObjectNestedImpl extends ProjectFluentImpl> implements WatchEventFluent.ProjectObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ProjectBuilder builder;
    
            ProjectObjectNestedImpl(Project item){
                    this.builder = new ProjectBuilder(this, item);
            }
            ProjectObjectNestedImpl(){
                    this.builder = new ProjectBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withProjectObject(builder.build());
    }
    public N endProjectObject(){
            return and();
    }

}
    public class PipelineTaskArgumentObjectNestedImpl extends PipelineTaskArgumentFluentImpl> implements WatchEventFluent.PipelineTaskArgumentObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentBuilder builder;
    
            PipelineTaskArgumentObjectNestedImpl(PipelineTaskArgument item){
                    this.builder = new PipelineTaskArgumentBuilder(this, item);
            }
            PipelineTaskArgumentObjectNestedImpl(){
                    this.builder = new PipelineTaskArgumentBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTaskArgumentObject(builder.build());
    }
    public N endPipelineTaskArgumentObject(){
            return and();
    }

}
    public class WatchEventObjectNestedImpl extends WatchEventFluentImpl> implements WatchEventFluent.WatchEventObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final WatchEventBuilder builder;
    
            WatchEventObjectNestedImpl(WatchEvent item){
                    this.builder = new WatchEventBuilder(this, item);
            }
            WatchEventObjectNestedImpl(){
                    this.builder = new WatchEventBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withWatchEventObject(builder.build());
    }
    public N endWatchEventObject(){
            return and();
    }

}
    public class ConfigMapEnvSourceObjectNestedImpl extends ConfigMapEnvSourceFluentImpl> implements WatchEventFluent.ConfigMapEnvSourceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ConfigMapEnvSourceBuilder builder;
    
            ConfigMapEnvSourceObjectNestedImpl(ConfigMapEnvSource item){
                    this.builder = new ConfigMapEnvSourceBuilder(this, item);
            }
            ConfigMapEnvSourceObjectNestedImpl(){
                    this.builder = new ConfigMapEnvSourceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withConfigMapEnvSourceObject(builder.build());
    }
    public N endConfigMapEnvSourceObject(){
            return and();
    }

}
    public class HostAliasObjectNestedImpl extends HostAliasFluentImpl> implements WatchEventFluent.HostAliasObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HostAliasBuilder builder;
    
            HostAliasObjectNestedImpl(HostAlias item){
                    this.builder = new HostAliasBuilder(this, item);
            }
            HostAliasObjectNestedImpl(){
                    this.builder = new HostAliasBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHostAliasObject(builder.build());
    }
    public N endHostAliasObject(){
            return and();
    }

}
    public class HTTPIngressRuleValueObjectNestedImpl extends HTTPIngressRuleValueFluentImpl> implements WatchEventFluent.HTTPIngressRuleValueObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final HTTPIngressRuleValueBuilder builder;
    
            HTTPIngressRuleValueObjectNestedImpl(HTTPIngressRuleValue item){
                    this.builder = new HTTPIngressRuleValueBuilder(this, item);
            }
            HTTPIngressRuleValueObjectNestedImpl(){
                    this.builder = new HTTPIngressRuleValueBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withHTTPIngressRuleValueObject(builder.build());
    }
    public N endHTTPIngressRuleValueObject(){
            return and();
    }

}
    public class EndpointPortObjectNestedImpl extends EndpointPortFluentImpl> implements WatchEventFluent.EndpointPortObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final EndpointPortBuilder builder;
    
            EndpointPortObjectNestedImpl(EndpointPort item){
                    this.builder = new EndpointPortBuilder(this, item);
            }
            EndpointPortObjectNestedImpl(){
                    this.builder = new EndpointPortBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withEndpointPortObject(builder.build());
    }
    public N endEndpointPortObject(){
            return and();
    }

}
    public class StatusCauseObjectNestedImpl extends StatusCauseFluentImpl> implements WatchEventFluent.StatusCauseObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final StatusCauseBuilder builder;
    
            StatusCauseObjectNestedImpl(StatusCause item){
                    this.builder = new StatusCauseBuilder(this, item);
            }
            StatusCauseObjectNestedImpl(){
                    this.builder = new StatusCauseBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withStatusCauseObject(builder.build());
    }
    public N endStatusCauseObject(){
            return and();
    }

}
    public class I18nNameObjectNestedImpl extends I18nNameFluentImpl> implements WatchEventFluent.I18nNameObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final I18nNameBuilder builder;
    
            I18nNameObjectNestedImpl(I18nName item){
                    this.builder = new I18nNameBuilder(this, item);
            }
            I18nNameObjectNestedImpl(){
                    this.builder = new I18nNameBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withI18nNameObject(builder.build());
    }
    public N endI18nNameObject(){
            return and();
    }

}
    public class PipelineRunLimitsObjectNestedImpl extends PipelineRunLimitsFluentImpl> implements WatchEventFluent.PipelineRunLimitsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineRunLimitsBuilder builder;
    
            PipelineRunLimitsObjectNestedImpl(PipelineRunLimits item){
                    this.builder = new PipelineRunLimitsBuilder(this, item);
            }
            PipelineRunLimitsObjectNestedImpl(){
                    this.builder = new PipelineRunLimitsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineRunLimitsObject(builder.build());
    }
    public N endPipelineRunLimitsObject(){
            return and();
    }

}
    public class NodeConditionObjectNestedImpl extends NodeConditionFluentImpl> implements WatchEventFluent.NodeConditionObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final NodeConditionBuilder builder;
    
            NodeConditionObjectNestedImpl(NodeCondition item){
                    this.builder = new NodeConditionBuilder(this, item);
            }
            NodeConditionObjectNestedImpl(){
                    this.builder = new NodeConditionBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withNodeConditionObject(builder.build());
    }
    public N endNodeConditionObject(){
            return and();
    }

}
    public class RollingUpdateDeploymentObjectNestedImpl extends RollingUpdateDeploymentFluentImpl> implements WatchEventFluent.RollingUpdateDeploymentObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final RollingUpdateDeploymentBuilder builder;
    
            RollingUpdateDeploymentObjectNestedImpl(RollingUpdateDeployment item){
                    this.builder = new RollingUpdateDeploymentBuilder(this, item);
            }
            RollingUpdateDeploymentObjectNestedImpl(){
                    this.builder = new RollingUpdateDeploymentBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withRollingUpdateDeploymentObject(builder.build());
    }
    public N endRollingUpdateDeploymentObject(){
            return and();
    }

}
    public class PipelineStageObjectNestedImpl extends PipelineStageFluentImpl> implements WatchEventFluent.PipelineStageObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineStageBuilder builder;
    
            PipelineStageObjectNestedImpl(PipelineStage item){
                    this.builder = new PipelineStageBuilder(this, item);
            }
            PipelineStageObjectNestedImpl(){
                    this.builder = new PipelineStageBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineStageObject(builder.build());
    }
    public N endPipelineStageObject(){
            return and();
    }

}
    public class OriginCodeRepositoryObjectNestedImpl extends OriginCodeRepositoryFluentImpl> implements WatchEventFluent.OriginCodeRepositoryObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final OriginCodeRepositoryBuilder builder;
    
            OriginCodeRepositoryObjectNestedImpl(OriginCodeRepository item){
                    this.builder = new OriginCodeRepositoryBuilder(this, item);
            }
            OriginCodeRepositoryObjectNestedImpl(){
                    this.builder = new OriginCodeRepositoryBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withOriginCodeRepositoryObject(builder.build());
    }
    public N endOriginCodeRepositoryObject(){
            return and();
    }

}
    public class ObjectReferenceObjectNestedImpl extends ObjectReferenceFluentImpl> implements WatchEventFluent.ObjectReferenceObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final ObjectReferenceBuilder builder;
    
            ObjectReferenceObjectNestedImpl(ObjectReference item){
                    this.builder = new ObjectReferenceBuilder(this, item);
            }
            ObjectReferenceObjectNestedImpl(){
                    this.builder = new ObjectReferenceBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withObjectReferenceObject(builder.build());
    }
    public N endObjectReferenceObject(){
            return and();
    }

}
    public class PipelineTemplateSpecObjectNestedImpl extends PipelineTemplateSpecFluentImpl> implements WatchEventFluent.PipelineTemplateSpecObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTemplateSpecBuilder builder;
    
            PipelineTemplateSpecObjectNestedImpl(PipelineTemplateSpec item){
                    this.builder = new PipelineTemplateSpecBuilder(this, item);
            }
            PipelineTemplateSpecObjectNestedImpl(){
                    this.builder = new PipelineTemplateSpecBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineTemplateSpecObject(builder.build());
    }
    public N endPipelineTemplateSpecObject(){
            return and();
    }

}
    public class PipelineStrategyJenkinsObjectNestedImpl extends PipelineStrategyJenkinsFluentImpl> implements WatchEventFluent.PipelineStrategyJenkinsObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineStrategyJenkinsBuilder builder;
    
            PipelineStrategyJenkinsObjectNestedImpl(PipelineStrategyJenkins item){
                    this.builder = new PipelineStrategyJenkinsBuilder(this, item);
            }
            PipelineStrategyJenkinsObjectNestedImpl(){
                    this.builder = new PipelineStrategyJenkinsBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPipelineStrategyJenkinsObject(builder.build());
    }
    public N endPipelineStrategyJenkinsObject(){
            return and();
    }

}
    public class PersistentVolumeObjectNestedImpl extends PersistentVolumeFluentImpl> implements WatchEventFluent.PersistentVolumeObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final PersistentVolumeBuilder builder;
    
            PersistentVolumeObjectNestedImpl(PersistentVolume item){
                    this.builder = new PersistentVolumeBuilder(this, item);
            }
            PersistentVolumeObjectNestedImpl(){
                    this.builder = new PersistentVolumeBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withPersistentVolumeObject(builder.build());
    }
    public N endPersistentVolumeObject(){
            return and();
    }

}
    public class CodeRepositoryObjectNestedImpl extends CodeRepositoryFluentImpl> implements WatchEventFluent.CodeRepositoryObjectNested,io.alauda.kubernetes.api.builder.Nested{

            private final CodeRepositoryBuilder builder;
    
            CodeRepositoryObjectNestedImpl(CodeRepository item){
                    this.builder = new CodeRepositoryBuilder(this, item);
            }
            CodeRepositoryObjectNestedImpl(){
                    this.builder = new CodeRepositoryBuilder(this);
            }
    
    public N and(){
            return (N) WatchEventFluentImpl.this.withCodeRepositoryObject(builder.build());
    }
    public N endCodeRepositoryObject(){
            return and();
    }

}


}
Related Artifacts