io.alauda.kubernetes.api.model.WatchEventFluent Maven / Gradle / Ivy
package io.alauda.kubernetes.api.model;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetCondition;
import java.lang.String;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionListFluent;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetListBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatusBuilder;
import io.alauda.kubernetes.api.model.authorization.ResourceAttributes;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionCondition;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewStatus;
import io.alauda.kubernetes.api.model.extensions.IngressTLSFluent;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyList;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNamesFluent;
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.NetworkPolicyListFluent;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewStatusFluent;
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.IDRangeFluent;
import io.alauda.kubernetes.api.model.extensions.DaemonSetFluent;
import io.alauda.kubernetes.api.model.extensions.IngressListFluent;
import io.alauda.kubernetes.api.model.extensions.StatefulSetFluent;
import io.alauda.kubernetes.api.model.extensions.DaemonSetUpdateStrategyBuilder;
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.authorization.SubjectAccessReviewStatusBuilder;
import io.alauda.kubernetes.api.model.version.Info;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.DaemonSetSpecFluent;
import io.alauda.kubernetes.api.model.extensions.DaemonSetSpecBuilder;
import io.alauda.kubernetes.api.model.authentication.TokenReviewFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPortFluent;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicySpec;
import io.alauda.kubernetes.api.model.extensions.RollbackConfig;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicy;
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.ScaleSpecFluent;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressRuleBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressFluent;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressPathFluent;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressRuleValueFluent;
import io.alauda.kubernetes.api.model.extensions.RollbackConfigBuilder;
import io.alauda.kubernetes.api.model.extensions.SupplementalGroupsStrategyOptionsFluent;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionConditionFluent;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewFluent;
import io.alauda.kubernetes.api.model.extensions.IngressStatus;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDeploymentFluent;
import io.alauda.kubernetes.api.model.authorization.LocalSubjectAccessReviewFluent;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDaemonSet;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollback;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDaemonSetFluent;
import io.alauda.kubernetes.api.model.extensions.DeploymentSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.SELinuxStrategyOptionsFluent;
import io.alauda.kubernetes.api.model.extensions.APIVersion;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateStatefulSetStrategy;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateStatefulSetStrategyBuilder;
import io.alauda.kubernetes.api.model.extensions.SupplementalGroupsStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentRollbackFluent;
import io.alauda.kubernetes.api.model.extensions.DeploymentConditionFluent;
import io.alauda.kubernetes.api.model.extensions.SELinuxStrategyOptions;
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.authentication.TokenReviewStatusFluent;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetStatus;
import io.alauda.kubernetes.api.model.extensions.DeploymentSpecFluent;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyFluent;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicyListFluent;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressListBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicySpecBuilder;
import io.alauda.kubernetes.api.model.extensions.PodSecurityPolicySpecFluent;
import io.alauda.kubernetes.api.model.extensions.DeploymentSpec;
import java.lang.Long;
import io.alauda.kubernetes.api.model.extensions.DaemonSet;
import io.alauda.kubernetes.api.model.extensions.StatefulSetStatus;
import io.alauda.kubernetes.api.model.authorization.NonResourceAttributesBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetListBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentFluent;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionFluent;
import io.alauda.kubernetes.api.model.extensions.IngressBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentStrategyFluent;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.alauda.kubernetes.api.model.extensions.KubernetesRunAsUserStrategyOptionsFluent;
import io.alauda.kubernetes.api.model.version.InfoFluent;
import io.alauda.kubernetes.api.model.extensions.IngressRule;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyListBuilder;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDeploymentBuilder;
import java.lang.Boolean;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPeerBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetList;
import javax.validation.Valid;
import java.lang.Object;
import io.alauda.kubernetes.api.model.extensions.APIVersionFluent;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceListBuilder;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateStatefulSetStrategyFluent;
import io.alauda.kubernetes.api.model.authorization.ResourceAttributesFluent;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetUpdateStrategyBuilder;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressRuleValueBuilder;
import io.alauda.kubernetes.api.model.authentication.UserInfoFluent;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressRuleValue;
import io.alauda.kubernetes.api.model.extensions.ScaleStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.RollbackConfigFluent;
import io.alauda.kubernetes.api.model.extensions.FSGroupStrategyOptions;
import io.alauda.kubernetes.api.builder.Fluent;
import io.alauda.kubernetes.api.model.extensions.DeploymentListFluent;
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.apiextensions.CustomResourceDefinitionNames;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyIngressRuleFluent;
import io.alauda.kubernetes.api.model.extensions.IngressRuleFluent;
import io.alauda.kubernetes.api.model.extensions.ScaleFluent;
import io.alauda.kubernetes.api.model.extensions.StatefulSetSpec;
import io.alauda.kubernetes.api.model.extensions.StatefulSetStatusBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionList;
import io.alauda.kubernetes.api.model.extensions.FSGroupStrategyOptionsFluent;
import io.alauda.kubernetes.api.model.authentication.TokenReviewStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyFluent;
import java.lang.Deprecated;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyList;
import io.alauda.kubernetes.api.model.extensions.Deployment;
import io.alauda.kubernetes.api.model.extensions.IngressSpecFluent;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetSpecFluent;
import io.alauda.kubernetes.api.model.authorization.NonResourceAttributes;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPort;
import io.alauda.kubernetes.api.model.extensions.StatefulSetStatusFluent;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceListFluent;
import io.alauda.kubernetes.api.model.extensions.SELinuxStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.IngressBackendFluent;
import io.alauda.kubernetes.api.model.extensions.IngressList;
import io.alauda.kubernetes.api.model.authentication.UserInfoBuilder;
import io.alauda.kubernetes.api.model.authorization.NonResourceAttributesFluent;
import io.alauda.kubernetes.api.model.extensions.IDRangeBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewSpecFluent;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDaemonSetBuilder;
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.apiextensions.CustomResourceDefinitionSpecFluent;
import io.alauda.kubernetes.api.model.extensions.StatefulSetList;
import io.alauda.kubernetes.api.model.authentication.TokenReviewSpecFluent;
import io.alauda.kubernetes.api.model.extensions.StatefulSetSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyIngressRule;
import java.util.Map;
import io.alauda.kubernetes.api.model.extensions.DeploymentBuilder;
import io.alauda.kubernetes.api.model.extensions.HostPortRangeFluent;
import io.alauda.kubernetes.api.model.extensions.DeploymentStatusFluent;
import io.alauda.kubernetes.api.model.extensions.IngressStatusFluent;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResource;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionSpec;
import io.alauda.kubernetes.api.model.extensions.DaemonSetStatusFluent;
import io.alauda.kubernetes.api.model.authentication.TokenReviewBuilder;
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.DeploymentStatus;
import io.alauda.kubernetes.api.model.extensions.IngressBackend;
import io.alauda.kubernetes.api.model.extensions.DaemonSetUpdateStrategyFluent;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetBuilder;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicySpec;
import io.alauda.kubernetes.api.model.extensions.ThirdPartyResourceBuilder;
import io.alauda.kubernetes.api.model.extensions.Ingress;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetSpec;
import io.alauda.kubernetes.api.model.extensions.FSGroupStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetBuilder;
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.StatefulSetListFluent;
import io.alauda.kubernetes.api.model.extensions.Scale;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatusFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicySpecFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyBuilder;
import io.alauda.kubernetes.api.model.extensions.ScaleSpecBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentConditionBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReview;
import io.alauda.kubernetes.api.model.extensions.DeploymentListBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetSpecFluent;
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.extensions.IDRange;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudgetListFluent;
import io.alauda.kubernetes.api.model.extensions.KubernetesRunAsUserStrategyOptionsBuilder;
import io.alauda.kubernetes.api.model.extensions.HostPortRangeBuilder;
import io.alauda.kubernetes.api.model.extensions.DeploymentCondition;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetSpecFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPortBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetListFluent;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetConditionBuilder;
import io.alauda.kubernetes.api.model.extensions.StatefulSetUpdateStrategy;
import java.lang.Integer;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.alauda.kubernetes.api.model.extensions.DaemonSetStatusBuilder;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetConditionFluent;
import io.alauda.kubernetes.api.model.extensions.ScaleStatusFluent;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionNamesBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetListFluent;
import io.alauda.kubernetes.api.model.extensions.SupplementalGroupsStrategyOptions;
import io.alauda.kubernetes.api.model.extensions.ScaleStatus;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPeer;
import io.alauda.kubernetes.api.model.extensions.IngressTLSBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetSpec;
import io.alauda.kubernetes.api.model.extensions.StatefulSetListBuilder;
import io.alauda.kubernetes.api.model.extensions.DaemonSetUpdateStrategy;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionListBuilder;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressPathBuilder;
import io.alauda.kubernetes.api.model.authorization.SubjectAccessReviewSpecBuilder;
import io.alauda.kubernetes.api.model.apiextensions.CustomResourceDefinitionStatus;
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.model.policy.PodDisruptionBudgetStatusFluent;
import io.alauda.kubernetes.api.model.extensions.StatefulSet;
import io.alauda.kubernetes.api.model.extensions.RollingUpdateDeployment;
import io.alauda.kubernetes.api.model.extensions.StatefulSetUpdateStrategyFluent;
import io.alauda.kubernetes.api.model.policy.PodDisruptionBudget;
import io.alauda.kubernetes.api.builder.Nested;
import io.alauda.kubernetes.api.model.extensions.HTTPIngressPath;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetFluent;
import io.alauda.kubernetes.api.model.extensions.ReplicaSetStatusFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicyPeerFluent;
import io.alauda.kubernetes.api.model.extensions.NetworkPolicySpecBuilder;
public interface WatchEventFluent> extends Fluent{
/**
* This method has been deprecated, please use method buildObject instead.
*/
@Deprecated public KubernetesResource getObject();
public KubernetesResource buildObject();
public A withObject(KubernetesResource object);
public Boolean hasObject();
public A withRepositoryCommitObject(RepositoryCommit repositoryCommitObject);
public WatchEventFluent.RepositoryCommitObjectNested withNewRepositoryCommitObject();
public WatchEventFluent.RepositoryCommitObjectNested withNewRepositoryCommitObjectLike(RepositoryCommit item);
public A withNewRepositoryCommitObject(String commitAt,String commitID,String commitMessage,String committerEmail,String committerName);
public A withAffinityObject(Affinity affinityObject);
public WatchEventFluent.AffinityObjectNested withNewAffinityObject();
public WatchEventFluent.AffinityObjectNested withNewAffinityObjectLike(Affinity item);
public A withNamedClusterObject(NamedCluster namedClusterObject);
public WatchEventFluent.NamedClusterObjectNested withNewNamedClusterObject();
public WatchEventFluent.NamedClusterObjectNested withNewNamedClusterObjectLike(NamedCluster item);
public A withAWSElasticBlockStoreVolumeSourceObject(AWSElasticBlockStoreVolumeSource aWSElasticBlockStoreVolumeSourceObject);
public WatchEventFluent.AWSElasticBlockStoreVolumeSourceObjectNested withNewAWSElasticBlockStoreVolumeSourceObject();
public WatchEventFluent.AWSElasticBlockStoreVolumeSourceObjectNested withNewAWSElasticBlockStoreVolumeSourceObjectLike(AWSElasticBlockStoreVolumeSource item);
public A withNewAWSElasticBlockStoreVolumeSourceObject(String fsType,Integer partition,Boolean readOnly,String volumeID);
public A withContextObject(Context contextObject);
public WatchEventFluent.ContextObjectNested withNewContextObject();
public WatchEventFluent.ContextObjectNested withNewContextObjectLike(Context item);
public A withServicePortObject(ServicePort servicePortObject);
public WatchEventFluent.ServicePortObjectNested withNewServicePortObject();
public WatchEventFluent.ServicePortObjectNested withNewServicePortObjectLike(ServicePort item);
public A withBindingObject(Binding bindingObject);
public WatchEventFluent.BindingObjectNested withNewBindingObject();
public WatchEventFluent.BindingObjectNested withNewBindingObjectLike(Binding item);
public A withAuthInfoObject(AuthInfo authInfoObject);
public WatchEventFluent.AuthInfoObjectNested withNewAuthInfoObject();
public WatchEventFluent.AuthInfoObjectNested withNewAuthInfoObjectLike(AuthInfo item);
public A withIngressObject(Ingress ingressObject);
public WatchEventFluent.IngressObjectNested withNewIngressObject();
public WatchEventFluent.IngressObjectNested withNewIngressObjectLike(Ingress item);
public A withClusterPipelineTaskTemplateListObject(ClusterPipelineTaskTemplateList clusterPipelineTaskTemplateListObject);
public WatchEventFluent.ClusterPipelineTaskTemplateListObjectNested withNewClusterPipelineTaskTemplateListObject();
public WatchEventFluent.ClusterPipelineTaskTemplateListObjectNested withNewClusterPipelineTaskTemplateListObjectLike(ClusterPipelineTaskTemplateList item);
public A withRollingUpdateStatefulSetStrategyObject(RollingUpdateStatefulSetStrategy rollingUpdateStatefulSetStrategyObject);
public WatchEventFluent.RollingUpdateStatefulSetStrategyObjectNested withNewRollingUpdateStatefulSetStrategyObject();
public WatchEventFluent.RollingUpdateStatefulSetStrategyObjectNested withNewRollingUpdateStatefulSetStrategyObjectLike(RollingUpdateStatefulSetStrategy item);
public A withNewRollingUpdateStatefulSetStrategyObject(Integer partition);
public A withLocalSubjectAccessReviewObject(LocalSubjectAccessReview localSubjectAccessReviewObject);
public WatchEventFluent.LocalSubjectAccessReviewObjectNested withNewLocalSubjectAccessReviewObject();
public WatchEventFluent.LocalSubjectAccessReviewObjectNested withNewLocalSubjectAccessReviewObjectLike(LocalSubjectAccessReview item);
public A withStatefulSetObject(StatefulSet statefulSetObject);
public WatchEventFluent.StatefulSetObjectNested withNewStatefulSetObject();
public WatchEventFluent.StatefulSetObjectNested withNewStatefulSetObjectLike(StatefulSet item);
public A withPipelineTaskArgumentSchemaObject(PipelineTaskArgumentSchema pipelineTaskArgumentSchemaObject);
public WatchEventFluent.PipelineTaskArgumentSchemaObjectNested withNewPipelineTaskArgumentSchemaObject();
public WatchEventFluent.PipelineTaskArgumentSchemaObjectNested withNewPipelineTaskArgumentSchemaObjectLike(PipelineTaskArgumentSchema item);
public A withNewPipelineTaskArgumentSchemaObject(String type);
public A withContainerObject(Container containerObject);
public WatchEventFluent.ContainerObjectNested withNewContainerObject();
public WatchEventFluent.ContainerObjectNested withNewContainerObjectLike(Container item);
public A withResourceQuotaSpecObject(ResourceQuotaSpec resourceQuotaSpecObject);
public WatchEventFluent.ResourceQuotaSpecObjectNested withNewResourceQuotaSpecObject();
public WatchEventFluent.ResourceQuotaSpecObjectNested withNewResourceQuotaSpecObjectLike(ResourceQuotaSpec item);
public A withPipelineTemplateTaskInstanceObject(PipelineTemplateTaskInstance pipelineTemplateTaskInstanceObject);
public WatchEventFluent.PipelineTemplateTaskInstanceObjectNested withNewPipelineTemplateTaskInstanceObject();
public WatchEventFluent.PipelineTemplateTaskInstanceObjectNested withNewPipelineTemplateTaskInstanceObjectLike(PipelineTemplateTaskInstance item);
public A withPipelineTemplateListObject(PipelineTemplateList pipelineTemplateListObject);
public WatchEventFluent.PipelineTemplateListObjectNested withNewPipelineTemplateListObject();
public WatchEventFluent.PipelineTemplateListObjectNested withNewPipelineTemplateListObjectLike(PipelineTemplateList item);
public A withPipelineTaskOptionObject(PipelineTaskOption pipelineTaskOptionObject);
public WatchEventFluent.PipelineTaskOptionObjectNested withNewPipelineTaskOptionObject();
public WatchEventFluent.PipelineTaskOptionObjectNested withNewPipelineTaskOptionObjectLike(PipelineTaskOption item);
public A withNewPipelineTaskOptionObject(Long timeout);
public A withJobSpecObject(JobSpec jobSpecObject);
public WatchEventFluent.JobSpecObjectNested withNewJobSpecObject();
public WatchEventFluent.JobSpecObjectNested withNewJobSpecObjectLike(JobSpec item);
public A withSecretListObject(SecretList secretListObject);
public WatchEventFluent.SecretListObjectNested withNewSecretListObject();
public WatchEventFluent.SecretListObjectNested withNewSecretListObjectLike(SecretList item);
public A withJenkinsListObject(JenkinsList jenkinsListObject);
public WatchEventFluent.JenkinsListObjectNested withNewJenkinsListObject();
public WatchEventFluent.JenkinsListObjectNested withNewJenkinsListObjectLike(JenkinsList item);
public A withLabelSelectorObject(LabelSelector labelSelectorObject);
public WatchEventFluent.LabelSelectorObjectNested withNewLabelSelectorObject();
public WatchEventFluent.LabelSelectorObjectNested withNewLabelSelectorObjectLike(LabelSelector item);
public A withCronJobSpecObject(CronJobSpec cronJobSpecObject);
public WatchEventFluent.CronJobSpecObjectNested withNewCronJobSpecObject();
public WatchEventFluent.CronJobSpecObjectNested withNewCronJobSpecObjectLike(CronJobSpec item);
public A withDeleteOptionsObject(DeleteOptions deleteOptionsObject);
public WatchEventFluent.DeleteOptionsObjectNested withNewDeleteOptionsObject();
public WatchEventFluent.DeleteOptionsObjectNested withNewDeleteOptionsObjectLike(DeleteOptions item);
public A withPipelineTriggerObject(PipelineTrigger pipelineTriggerObject);
public WatchEventFluent.PipelineTriggerObjectNested withNewPipelineTriggerObject();
public WatchEventFluent.PipelineTriggerObjectNested withNewPipelineTriggerObjectLike(PipelineTrigger item);
public A withDeploymentRollbackObject(DeploymentRollback deploymentRollbackObject);
public WatchEventFluent.DeploymentRollbackObjectNested withNewDeploymentRollbackObject();
public WatchEventFluent.DeploymentRollbackObjectNested withNewDeploymentRollbackObjectLike(DeploymentRollback item);
public A withSecretVolumeSourceObject(SecretVolumeSource secretVolumeSourceObject);
public WatchEventFluent.SecretVolumeSourceObjectNested withNewSecretVolumeSourceObject();
public WatchEventFluent.SecretVolumeSourceObjectNested withNewSecretVolumeSourceObjectLike(SecretVolumeSource item);
public A withDownwardAPIProjectionObject(DownwardAPIProjection downwardAPIProjectionObject);
public WatchEventFluent.DownwardAPIProjectionObjectNested withNewDownwardAPIProjectionObject();
public WatchEventFluent.DownwardAPIProjectionObjectNested withNewDownwardAPIProjectionObjectLike(DownwardAPIProjection item);
public A withLoadBalancerIngressObject(LoadBalancerIngress loadBalancerIngressObject);
public WatchEventFluent.LoadBalancerIngressObjectNested withNewLoadBalancerIngressObject();
public WatchEventFluent.LoadBalancerIngressObjectNested withNewLoadBalancerIngressObjectLike(LoadBalancerIngress item);
public A withNewLoadBalancerIngressObject(String hostname,String ip);
public A withCodeRepoBindingAccountObject(CodeRepoBindingAccount codeRepoBindingAccountObject);
public WatchEventFluent.CodeRepoBindingAccountObjectNested withNewCodeRepoBindingAccountObject();
public WatchEventFluent.CodeRepoBindingAccountObjectNested withNewCodeRepoBindingAccountObjectLike(CodeRepoBindingAccount item);
public A withHorizontalPodAutoscalerSpecObject(HorizontalPodAutoscalerSpec horizontalPodAutoscalerSpecObject);
public WatchEventFluent.HorizontalPodAutoscalerSpecObjectNested withNewHorizontalPodAutoscalerSpecObject();
public WatchEventFluent.HorizontalPodAutoscalerSpecObjectNested withNewHorizontalPodAutoscalerSpecObjectLike(HorizontalPodAutoscalerSpec item);
public A withProjectNamespaceStatusObject(ProjectNamespaceStatus projectNamespaceStatusObject);
public WatchEventFluent.ProjectNamespaceStatusObjectNested withNewProjectNamespaceStatusObject();
public WatchEventFluent.ProjectNamespaceStatusObjectNested withNewProjectNamespaceStatusObjectLike(ProjectNamespaceStatus item);
public A withNewProjectNamespaceStatusObject(String name,String status);
public A withKubernetesRunAsUserStrategyOptionsObject(KubernetesRunAsUserStrategyOptions kubernetesRunAsUserStrategyOptionsObject);
public WatchEventFluent.KubernetesRunAsUserStrategyOptionsObjectNested withNewKubernetesRunAsUserStrategyOptionsObject();
public WatchEventFluent.KubernetesRunAsUserStrategyOptionsObjectNested withNewKubernetesRunAsUserStrategyOptionsObjectLike(KubernetesRunAsUserStrategyOptions item);
public A withStatusDetailsObject(StatusDetails statusDetailsObject);
public WatchEventFluent.StatusDetailsObjectNested withNewStatusDetailsObject();
public WatchEventFluent.StatusDetailsObjectNested withNewStatusDetailsObjectLike(StatusDetails item);
public A withPipelineTaskApproveObject(PipelineTaskApprove pipelineTaskApproveObject);
public WatchEventFluent.PipelineTaskApproveObjectNested withNewPipelineTaskApproveObject();
public WatchEventFluent.PipelineTaskApproveObjectNested withNewPipelineTaskApproveObjectLike(PipelineTaskApprove item);
public A withNewPipelineTaskApproveObject(String message,Long timeout);
public A withPodSecurityPolicyObject(PodSecurityPolicy podSecurityPolicyObject);
public WatchEventFluent.PodSecurityPolicyObjectNested withNewPodSecurityPolicyObject();
public WatchEventFluent.PodSecurityPolicyObjectNested withNewPodSecurityPolicyObjectLike(PodSecurityPolicy item);
public A withWeightedPodAffinityTermObject(WeightedPodAffinityTerm weightedPodAffinityTermObject);
public WatchEventFluent.WeightedPodAffinityTermObjectNested withNewWeightedPodAffinityTermObject();
public WatchEventFluent.WeightedPodAffinityTermObjectNested withNewWeightedPodAffinityTermObjectLike(WeightedPodAffinityTerm item);
public A withPipelineObject(Pipeline pipelineObject);
public WatchEventFluent.PipelineObjectNested withNewPipelineObject();
public WatchEventFluent.PipelineObjectNested withNewPipelineObjectLike(Pipeline item);
public A withNodeListObject(NodeList nodeListObject);
public WatchEventFluent.NodeListObjectNested withNewNodeListObject();
public WatchEventFluent.NodeListObjectNested withNewNodeListObjectLike(NodeList item);
public A withCinderVolumeSourceObject(CinderVolumeSource cinderVolumeSourceObject);
public WatchEventFluent.CinderVolumeSourceObjectNested withNewCinderVolumeSourceObject();
public WatchEventFluent.CinderVolumeSourceObjectNested withNewCinderVolumeSourceObjectLike(CinderVolumeSource item);
public A withNewCinderVolumeSourceObject(String fsType,Boolean readOnly,String volumeID);
public A withCustomResourceDefinitionStatusObject(CustomResourceDefinitionStatus customResourceDefinitionStatusObject);
public WatchEventFluent.CustomResourceDefinitionStatusObjectNested withNewCustomResourceDefinitionStatusObject();
public WatchEventFluent.CustomResourceDefinitionStatusObjectNested withNewCustomResourceDefinitionStatusObjectLike(CustomResourceDefinitionStatus item);
public A withNetworkPolicySpecObject(NetworkPolicySpec networkPolicySpecObject);
public WatchEventFluent.NetworkPolicySpecObjectNested withNewNetworkPolicySpecObject();
public WatchEventFluent.NetworkPolicySpecObjectNested withNewNetworkPolicySpecObjectLike(NetworkPolicySpec item);
public A withLocalVolumeSourceObject(LocalVolumeSource localVolumeSourceObject);
public WatchEventFluent.LocalVolumeSourceObjectNested withNewLocalVolumeSourceObject();
public WatchEventFluent.LocalVolumeSourceObjectNested withNewLocalVolumeSourceObjectLike(LocalVolumeSource item);
public A withNewLocalVolumeSourceObject(String path);
public A withResourceQuotaObject(ResourceQuota resourceQuotaObject);
public WatchEventFluent.ResourceQuotaObjectNested withNewResourceQuotaObject();
public WatchEventFluent.ResourceQuotaObjectNested withNewResourceQuotaObjectLike(ResourceQuota item);
public A withPodListObject(PodList podListObject);
public WatchEventFluent.PodListObjectNested withNewPodListObject();
public WatchEventFluent.PodListObjectNested withNewPodListObjectLike(PodList item);
public A withUserInfoObject(UserInfo userInfoObject);
public WatchEventFluent.UserInfoObjectNested withNewUserInfoObject();
public WatchEventFluent.UserInfoObjectNested withNewUserInfoObjectLike(UserInfo item);
public A withPipelineSourceSvnObject(PipelineSourceSvn pipelineSourceSvnObject);
public WatchEventFluent.PipelineSourceSvnObjectNested withNewPipelineSourceSvnObject();
public WatchEventFluent.PipelineSourceSvnObjectNested withNewPipelineSourceSvnObjectLike(PipelineSourceSvn item);
public A withNewPipelineSourceSvnObject(String uri);
public A withCustomResourceDefinitionSpecObject(CustomResourceDefinitionSpec customResourceDefinitionSpecObject);
public WatchEventFluent.CustomResourceDefinitionSpecObjectNested withNewCustomResourceDefinitionSpecObject();
public WatchEventFluent.CustomResourceDefinitionSpecObjectNested withNewCustomResourceDefinitionSpecObjectLike(CustomResourceDefinitionSpec item);
public A withCodeRepositoryStatusObject(CodeRepositoryStatus codeRepositoryStatusObject);
public WatchEventFluent.CodeRepositoryStatusObjectNested withNewCodeRepositoryStatusObject();
public WatchEventFluent.CodeRepositoryStatusObjectNested withNewCodeRepositoryStatusObjectLike(CodeRepositoryStatus item);
public A withAzureFileVolumeSourceObject(AzureFileVolumeSource azureFileVolumeSourceObject);
public WatchEventFluent.AzureFileVolumeSourceObjectNested withNewAzureFileVolumeSourceObject();
public WatchEventFluent.AzureFileVolumeSourceObjectNested withNewAzureFileVolumeSourceObjectLike(AzureFileVolumeSource item);
public A withNewAzureFileVolumeSourceObject(Boolean readOnly,String secretName,String shareName);
public A withCodeRepoServiceSpecObject(CodeRepoServiceSpec codeRepoServiceSpecObject);
public WatchEventFluent.CodeRepoServiceSpecObjectNested withNewCodeRepoServiceSpecObject();
public WatchEventFluent.CodeRepoServiceSpecObjectNested withNewCodeRepoServiceSpecObjectLike(CodeRepoServiceSpec item);
public A withServiceAccountObject(ServiceAccount serviceAccountObject);
public WatchEventFluent.ServiceAccountObjectNested withNewServiceAccountObject();
public WatchEventFluent.ServiceAccountObjectNested withNewServiceAccountObjectLike(ServiceAccount item);
public A withCodeRepoBindingSpecObject(CodeRepoBindingSpec codeRepoBindingSpecObject);
public WatchEventFluent.CodeRepoBindingSpecObjectNested withNewCodeRepoBindingSpecObject();
public WatchEventFluent.CodeRepoBindingSpecObjectNested withNewCodeRepoBindingSpecObjectLike(CodeRepoBindingSpec item);
public A withStorageOSPersistentVolumeSourceObject(StorageOSPersistentVolumeSource storageOSPersistentVolumeSourceObject);
public WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested withNewStorageOSPersistentVolumeSourceObject();
public WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested withNewStorageOSPersistentVolumeSourceObjectLike(StorageOSPersistentVolumeSource item);
public A withLimitRangeSpecObject(LimitRangeSpec limitRangeSpecObject);
public WatchEventFluent.LimitRangeSpecObjectNested withNewLimitRangeSpecObject();
public WatchEventFluent.LimitRangeSpecObjectNested withNewLimitRangeSpecObjectLike(LimitRangeSpec item);
public A withPipelineStageInstanceObject(PipelineStageInstance pipelineStageInstanceObject);
public WatchEventFluent.PipelineStageInstanceObjectNested withNewPipelineStageInstanceObject();
public WatchEventFluent.PipelineStageInstanceObjectNested withNewPipelineStageInstanceObjectLike(PipelineStageInstance item);
public A withProjectListObject(ProjectList projectListObject);
public WatchEventFluent.ProjectListObjectNested withNewProjectListObject();
public WatchEventFluent.ProjectListObjectNested withNewProjectListObjectLike(ProjectList item);
public A withConfigMapObject(ConfigMap configMapObject);
public WatchEventFluent.ConfigMapObjectNested withNewConfigMapObject();
public WatchEventFluent.ConfigMapObjectNested withNewConfigMapObjectLike(ConfigMap item);
public A withPipelineCauseObject(PipelineCause pipelineCauseObject);
public WatchEventFluent.PipelineCauseObjectNested withNewPipelineCauseObject();
public WatchEventFluent.PipelineCauseObjectNested withNewPipelineCauseObjectLike(PipelineCause item);
public A withNewPipelineCauseObject(String message,String type);
public A withVolumeObject(Volume volumeObject);
public WatchEventFluent.VolumeObjectNested withNewVolumeObject();
public WatchEventFluent.VolumeObjectNested withNewVolumeObjectLike(Volume item);
public A withFSGroupStrategyOptionsObject(FSGroupStrategyOptions fSGroupStrategyOptionsObject);
public WatchEventFluent.FSGroupStrategyOptionsObjectNested withNewFSGroupStrategyOptionsObject();
public WatchEventFluent.FSGroupStrategyOptionsObjectNested withNewFSGroupStrategyOptionsObjectLike(FSGroupStrategyOptions item);
public A withPipelineStatusJenkinsObject(PipelineStatusJenkins pipelineStatusJenkinsObject);
public WatchEventFluent.PipelineStatusJenkinsObjectNested withNewPipelineStatusJenkinsObject();
public WatchEventFluent.PipelineStatusJenkinsObjectNested withNewPipelineStatusJenkinsObjectLike(PipelineStatusJenkins item);
public A withNewPipelineStatusJenkinsObject(String build,String result,String stages,String startStageID,String status);
public A withJenkinsBindingObject(JenkinsBinding jenkinsBindingObject);
public WatchEventFluent.JenkinsBindingObjectNested withNewJenkinsBindingObject();
public WatchEventFluent.JenkinsBindingObjectNested withNewJenkinsBindingObjectLike(JenkinsBinding item);
public A withPipelineTemplateObject(PipelineTemplate pipelineTemplateObject);
public WatchEventFluent.PipelineTemplateObjectNested withNewPipelineTemplateObject();
public WatchEventFluent.PipelineTemplateObjectNested withNewPipelineTemplateObjectLike(PipelineTemplate item);
public A withNodeAffinityObject(NodeAffinity nodeAffinityObject);
public WatchEventFluent.NodeAffinityObjectNested withNewNodeAffinityObject();
public WatchEventFluent.NodeAffinityObjectNested withNewNodeAffinityObjectLike(NodeAffinity item);
public A withPipelineConfigStatusObject(PipelineConfigStatus pipelineConfigStatusObject);
public WatchEventFluent.PipelineConfigStatusObjectNested withNewPipelineConfigStatusObject();
public WatchEventFluent.PipelineConfigStatusObjectNested withNewPipelineConfigStatusObjectLike(PipelineConfigStatus item);
public A withConfigMapListObject(ConfigMapList configMapListObject);
public WatchEventFluent.ConfigMapListObjectNested withNewConfigMapListObject();
public WatchEventFluent.ConfigMapListObjectNested withNewConfigMapListObjectLike(ConfigMapList item);
public A withPipelineTriggeScheduleObject(PipelineTriggeSchedule pipelineTriggeScheduleObject);
public WatchEventFluent.PipelineTriggeScheduleObjectNested withNewPipelineTriggeScheduleObject();
public WatchEventFluent.PipelineTriggeScheduleObjectNested withNewPipelineTriggeScheduleObjectLike(PipelineTriggeSchedule item);
public A withPipelineTaskTemplateListObject(PipelineTaskTemplateList pipelineTaskTemplateListObject);
public WatchEventFluent.PipelineTaskTemplateListObjectNested withNewPipelineTaskTemplateListObject();
public WatchEventFluent.PipelineTaskTemplateListObjectNested withNewPipelineTaskTemplateListObjectLike(PipelineTaskTemplateList item);
public A withDaemonSetStatusObject(DaemonSetStatus daemonSetStatusObject);
public WatchEventFluent.DaemonSetStatusObjectNested withNewDaemonSetStatusObject();
public WatchEventFluent.DaemonSetStatusObjectNested withNewDaemonSetStatusObjectLike(DaemonSetStatus item);
public A withBaseKubernetesListObject(BaseKubernetesList baseKubernetesListObject);
public WatchEventFluent.BaseKubernetesListObjectNested withNewBaseKubernetesListObject();
public WatchEventFluent.BaseKubernetesListObjectNested withNewBaseKubernetesListObjectLike(BaseKubernetesList item);
public A withInitializerObject(Initializer initializerObject);
public WatchEventFluent.InitializerObjectNested withNewInitializerObject();
public WatchEventFluent.InitializerObjectNested withNewInitializerObjectLike(Initializer item);
public A withNewInitializerObject(String name);
public A withStatusObject(Status statusObject);
public WatchEventFluent.StatusObjectNested withNewStatusObject();
public WatchEventFluent.StatusObjectNested withNewStatusObjectLike(Status item);
public A withCronJobObject(CronJob cronJobObject);
public WatchEventFluent.CronJobObjectNested withNewCronJobObject();
public WatchEventFluent.CronJobObjectNested withNewCronJobObjectLike(CronJob item);
public A withListMetaObject(ListMeta listMetaObject);
public WatchEventFluent.ListMetaObjectNested withNewListMetaObject();
public WatchEventFluent.ListMetaObjectNested withNewListMetaObjectLike(ListMeta item);
public A withNewListMetaObject(String resourceVersion,String selfLink);
public A withComponentStatusListObject(ComponentStatusList componentStatusListObject);
public WatchEventFluent.ComponentStatusListObjectNested withNewComponentStatusListObject();
public WatchEventFluent.ComponentStatusListObjectNested withNewComponentStatusListObjectLike(ComponentStatusList item);
public A withJenkinsBindingListObject(JenkinsBindingList jenkinsBindingListObject);
public WatchEventFluent.JenkinsBindingListObjectNested withNewJenkinsBindingListObject();
public WatchEventFluent.JenkinsBindingListObjectNested withNewJenkinsBindingListObjectLike(JenkinsBindingList item);
public A withBindingConditionObject(BindingCondition bindingConditionObject);
public WatchEventFluent.BindingConditionObjectNested withNewBindingConditionObject();
public WatchEventFluent.BindingConditionObjectNested withNewBindingConditionObjectLike(BindingCondition item);
public A withNodeStatusObject(NodeStatus nodeStatusObject);
public WatchEventFluent.NodeStatusObjectNested withNewNodeStatusObject();
public WatchEventFluent.NodeStatusObjectNested withNewNodeStatusObjectLike(NodeStatus item);
public A withGlobalParameterObject(GlobalParameter globalParameterObject);
public WatchEventFluent.GlobalParameterObjectNested withNewGlobalParameterObject();
public WatchEventFluent.GlobalParameterObjectNested withNewGlobalParameterObjectLike(GlobalParameter item);
public A withTokenReviewSpecObject(TokenReviewSpec tokenReviewSpecObject);
public WatchEventFluent.TokenReviewSpecObjectNested withNewTokenReviewSpecObject();
public WatchEventFluent.TokenReviewSpecObjectNested withNewTokenReviewSpecObjectLike(TokenReviewSpec item);
public A withNewTokenReviewSpecObject(String token);
public A withPipelineEnvironmentObject(PipelineEnvironment pipelineEnvironmentObject);
public WatchEventFluent.PipelineEnvironmentObjectNested withNewPipelineEnvironmentObject();
public WatchEventFluent.PipelineEnvironmentObjectNested withNewPipelineEnvironmentObjectLike(PipelineEnvironment item);
public A withNewPipelineEnvironmentObject(String name,String value);
public A withEventListObject(EventList eventListObject);
public WatchEventFluent.EventListObjectNested withNewEventListObject();
public WatchEventFluent.EventListObjectNested withNewEventListObjectLike(EventList item);
public A withVolumeMountObject(VolumeMount volumeMountObject);
public WatchEventFluent.VolumeMountObjectNested withNewVolumeMountObject();
public WatchEventFluent.VolumeMountObjectNested withNewVolumeMountObjectLike(VolumeMount item);
public A withNewVolumeMountObject(String mountPath,String name,Boolean readOnly,String subPath);
public A withSubjectAccessReviewObject(SubjectAccessReview subjectAccessReviewObject);
public WatchEventFluent.SubjectAccessReviewObjectNested withNewSubjectAccessReviewObject();
public WatchEventFluent.SubjectAccessReviewObjectNested withNewSubjectAccessReviewObjectLike(SubjectAccessReview item);
public A withSELinuxOptionsObject(SELinuxOptions sELinuxOptionsObject);
public WatchEventFluent.SELinuxOptionsObjectNested withNewSELinuxOptionsObject();
public WatchEventFluent.SELinuxOptionsObjectNested withNewSELinuxOptionsObjectLike(SELinuxOptions item);
public A withNewSELinuxOptionsObject(String level,String role,String type,String user);
public A withDeploymentSpecObject(DeploymentSpec deploymentSpecObject);
public WatchEventFluent.DeploymentSpecObjectNested withNewDeploymentSpecObject();
public WatchEventFluent.DeploymentSpecObjectNested withNewDeploymentSpecObjectLike(DeploymentSpec item);
public A withPersistentVolumeClaimListObject(PersistentVolumeClaimList persistentVolumeClaimListObject);
public WatchEventFluent.PersistentVolumeClaimListObjectNested withNewPersistentVolumeClaimListObject();
public WatchEventFluent.PersistentVolumeClaimListObjectNested withNewPersistentVolumeClaimListObjectLike(PersistentVolumeClaimList item);
public A withPodTemplateObject(PodTemplate podTemplateObject);
public WatchEventFluent.PodTemplateObjectNested withNewPodTemplateObject();
public WatchEventFluent.PodTemplateObjectNested withNewPodTemplateObjectLike(PodTemplate item);
public A withFCVolumeSourceObject(FCVolumeSource fCVolumeSourceObject);
public WatchEventFluent.FCVolumeSourceObjectNested withNewFCVolumeSourceObject();
public WatchEventFluent.FCVolumeSourceObjectNested withNewFCVolumeSourceObjectLike(FCVolumeSource item);
public A withPipelineStatusObject(PipelineStatus pipelineStatusObject);
public WatchEventFluent.PipelineStatusObjectNested withNewPipelineStatusObject();
public WatchEventFluent.PipelineStatusObjectNested withNewPipelineStatusObjectLike(PipelineStatus item);
public A withPipelineTemplateArgumentValueObject(PipelineTemplateArgumentValue pipelineTemplateArgumentValueObject);
public WatchEventFluent.PipelineTemplateArgumentValueObjectNested withNewPipelineTemplateArgumentValueObject();
public WatchEventFluent.PipelineTemplateArgumentValueObjectNested withNewPipelineTemplateArgumentValueObjectLike(PipelineTemplateArgumentValue item);
public A withDaemonSetSpecObject(DaemonSetSpec daemonSetSpecObject);
public WatchEventFluent.DaemonSetSpecObjectNested withNewDaemonSetSpecObject();
public WatchEventFluent.DaemonSetSpecObjectNested withNewDaemonSetSpecObjectLike(DaemonSetSpec item);
public A withPipelineStrategyObject(PipelineStrategy pipelineStrategyObject);
public WatchEventFluent.PipelineStrategyObjectNested withNewPipelineStrategyObject();
public WatchEventFluent.PipelineStrategyObjectNested withNewPipelineStrategyObjectLike(PipelineStrategy item);
public A withConditionObject(Condition conditionObject);
public WatchEventFluent.ConditionObjectNested withNewConditionObject();
public WatchEventFluent.ConditionObjectNested withNewConditionObjectLike(Condition item);
public A withNewConditionObject(String lastAttempt,String message,String reason,String status,String type);
public A withContainerStateWaitingObject(ContainerStateWaiting containerStateWaitingObject);
public WatchEventFluent.ContainerStateWaitingObjectNested withNewContainerStateWaitingObject();
public WatchEventFluent.ContainerStateWaitingObjectNested withNewContainerStateWaitingObjectLike(ContainerStateWaiting item);
public A withNewContainerStateWaitingObject(String message,String reason);
public A withTokenReviewObject(TokenReview tokenReviewObject);
public WatchEventFluent.TokenReviewObjectNested withNewTokenReviewObject();
public WatchEventFluent.TokenReviewObjectNested withNewTokenReviewObjectLike(TokenReview item);
public A withScaleSpecObject(ScaleSpec scaleSpecObject);
public WatchEventFluent.ScaleSpecObjectNested withNewScaleSpecObject();
public WatchEventFluent.ScaleSpecObjectNested withNewScaleSpecObjectLike(ScaleSpec item);
public A withNewScaleSpecObject(Integer replicas);
public A withCodeRepoBindingListObject(CodeRepoBindingList codeRepoBindingListObject);
public WatchEventFluent.CodeRepoBindingListObjectNested withNewCodeRepoBindingListObject();
public WatchEventFluent.CodeRepoBindingListObjectNested withNewCodeRepoBindingListObjectLike(CodeRepoBindingList item);
public A withNetworkPolicyPeerObject(NetworkPolicyPeer networkPolicyPeerObject);
public WatchEventFluent.NetworkPolicyPeerObjectNested withNewNetworkPolicyPeerObject();
public WatchEventFluent.NetworkPolicyPeerObjectNested withNewNetworkPolicyPeerObjectLike(NetworkPolicyPeer item);
public A withPreferencesObject(Preferences preferencesObject);
public WatchEventFluent.PreferencesObjectNested withNewPreferencesObject();
public WatchEventFluent.PreferencesObjectNested withNewPreferencesObjectLike(Preferences item);
public A withMultiBranchBehavioursObject(MultiBranchBehaviours multiBranchBehavioursObject);
public WatchEventFluent.MultiBranchBehavioursObjectNested withNewMultiBranchBehavioursObject();
public WatchEventFluent.MultiBranchBehavioursObjectNested withNewMultiBranchBehavioursObjectLike(MultiBranchBehaviours item);
public A withNodeDaemonEndpointsObject(NodeDaemonEndpoints nodeDaemonEndpointsObject);
public WatchEventFluent.NodeDaemonEndpointsObjectNested withNewNodeDaemonEndpointsObject();
public WatchEventFluent.NodeDaemonEndpointsObjectNested withNewNodeDaemonEndpointsObjectLike(NodeDaemonEndpoints item);
public A withPersistentVolumeListObject(PersistentVolumeList persistentVolumeListObject);
public WatchEventFluent.PersistentVolumeListObjectNested withNewPersistentVolumeListObject();
public WatchEventFluent.PersistentVolumeListObjectNested withNewPersistentVolumeListObjectLike(PersistentVolumeList item);
public A withLimitRangeItemObject(LimitRangeItem limitRangeItemObject);
public WatchEventFluent.LimitRangeItemObjectNested withNewLimitRangeItemObject();
public WatchEventFluent.LimitRangeItemObjectNested withNewLimitRangeItemObjectLike(LimitRangeItem item);
public A withDaemonSetUpdateStrategyObject(DaemonSetUpdateStrategy daemonSetUpdateStrategyObject);
public WatchEventFluent.DaemonSetUpdateStrategyObjectNested withNewDaemonSetUpdateStrategyObject();
public WatchEventFluent.DaemonSetUpdateStrategyObjectNested withNewDaemonSetUpdateStrategyObjectLike(DaemonSetUpdateStrategy item);
public A withCustomResourceDefinitionObject(CustomResourceDefinition customResourceDefinitionObject);
public WatchEventFluent.CustomResourceDefinitionObjectNested withNewCustomResourceDefinitionObject();
public WatchEventFluent.CustomResourceDefinitionObjectNested withNewCustomResourceDefinitionObjectLike(CustomResourceDefinition item);
public A withIngressListObject(IngressList ingressListObject);
public WatchEventFluent.IngressListObjectNested withNewIngressListObject();
public WatchEventFluent.IngressListObjectNested withNewIngressListObjectLike(IngressList item);
public A withFlexVolumeSourceObject(FlexVolumeSource flexVolumeSourceObject);
public WatchEventFluent.FlexVolumeSourceObjectNested withNewFlexVolumeSourceObject();
public WatchEventFluent.FlexVolumeSourceObjectNested withNewFlexVolumeSourceObjectLike(FlexVolumeSource item);
public A withJenkinsAgentObject(JenkinsAgent jenkinsAgentObject);
public WatchEventFluent.JenkinsAgentObjectNested withNewJenkinsAgentObject();
public WatchEventFluent.JenkinsAgentObjectNested withNewJenkinsAgentObjectLike(JenkinsAgent item);
public A withNewJenkinsAgentObject(String label);
public A withDeploymentConditionObject(DeploymentCondition deploymentConditionObject);
public WatchEventFluent.DeploymentConditionObjectNested withNewDeploymentConditionObject();
public WatchEventFluent.DeploymentConditionObjectNested withNewDeploymentConditionObjectLike(DeploymentCondition item);
public A withConfigObject(Config configObject);
public WatchEventFluent.ConfigObjectNested withNewConfigObject();
public WatchEventFluent.ConfigObjectNested withNewConfigObjectLike(Config item);
public A withPipelineParameterObject(PipelineParameter pipelineParameterObject);
public WatchEventFluent.PipelineParameterObjectNested withNewPipelineParameterObject();
public WatchEventFluent.PipelineParameterObjectNested withNewPipelineParameterObjectLike(PipelineParameter item);
public A withNewPipelineParameterObject(String description,String name,String type,String value);
public A withNamespaceListObject(NamespaceList namespaceListObject);
public WatchEventFluent.NamespaceListObjectNested withNewNamespaceListObject();
public WatchEventFluent.NamespaceListObjectNested withNewNamespaceListObjectLike(NamespaceList item);
public A withPodDisruptionBudgetStatusObject(PodDisruptionBudgetStatus podDisruptionBudgetStatusObject);
public WatchEventFluent.PodDisruptionBudgetStatusObjectNested withNewPodDisruptionBudgetStatusObject();
public WatchEventFluent.PodDisruptionBudgetStatusObjectNested withNewPodDisruptionBudgetStatusObjectLike(PodDisruptionBudgetStatus item);
public A withCodeRepositorySpecObject(CodeRepositorySpec codeRepositorySpecObject);
public WatchEventFluent.CodeRepositorySpecObjectNested withNewCodeRepositorySpecObject();
public WatchEventFluent.CodeRepositorySpecObjectNested withNewCodeRepositorySpecObjectLike(CodeRepositorySpec item);
public A withPodDisruptionBudgetListObject(PodDisruptionBudgetList podDisruptionBudgetListObject);
public WatchEventFluent.PodDisruptionBudgetListObjectNested withNewPodDisruptionBudgetListObject();
public WatchEventFluent.PodDisruptionBudgetListObjectNested withNewPodDisruptionBudgetListObjectLike(PodDisruptionBudgetList item);
public A withDeploymentStatusObject(DeploymentStatus deploymentStatusObject);
public WatchEventFluent.DeploymentStatusObjectNested withNewDeploymentStatusObject();
public WatchEventFluent.DeploymentStatusObjectNested withNewDeploymentStatusObjectLike(DeploymentStatus item);
public A withStorageClassObject(StorageClass storageClassObject);
public WatchEventFluent.StorageClassObjectNested withNewStorageClassObject();
public WatchEventFluent.StorageClassObjectNested withNewStorageClassObjectLike(StorageClass item);
public A withUserAccountObject(UserAccount userAccountObject);
public WatchEventFluent.UserAccountObjectNested withNewUserAccountObject();
public WatchEventFluent.UserAccountObjectNested withNewUserAccountObjectLike(UserAccount item);
public A withQuobyteVolumeSourceObject(QuobyteVolumeSource quobyteVolumeSourceObject);
public WatchEventFluent.QuobyteVolumeSourceObjectNested withNewQuobyteVolumeSourceObject();
public WatchEventFluent.QuobyteVolumeSourceObjectNested withNewQuobyteVolumeSourceObjectLike(QuobyteVolumeSource item);
public A withNewQuobyteVolumeSourceObject(String group,Boolean readOnly,String registry,String user,String volume);
public A withMultiBranchOrphanObject(MultiBranchOrphan multiBranchOrphanObject);
public WatchEventFluent.MultiBranchOrphanObjectNested withNewMultiBranchOrphanObject();
public WatchEventFluent.MultiBranchOrphanObjectNested withNewMultiBranchOrphanObjectLike(MultiBranchOrphan item);
public A withNewMultiBranchOrphanObject(Integer days,Integer max);
public A withPreferredSchedulingTermObject(PreferredSchedulingTerm preferredSchedulingTermObject);
public WatchEventFluent.PreferredSchedulingTermObjectNested withNewPreferredSchedulingTermObject();
public WatchEventFluent.PreferredSchedulingTermObjectNested withNewPreferredSchedulingTermObjectLike(PreferredSchedulingTerm item);
public A withHostPortRangeObject(HostPortRange hostPortRangeObject);
public WatchEventFluent.HostPortRangeObjectNested withNewHostPortRangeObject();
public WatchEventFluent.HostPortRangeObjectNested withNewHostPortRangeObjectLike(HostPortRange item);
public A withNewHostPortRangeObject(Integer max,Integer min);
public A withPodSecurityPolicyListObject(PodSecurityPolicyList podSecurityPolicyListObject);
public WatchEventFluent.PodSecurityPolicyListObjectNested withNewPodSecurityPolicyListObject();
public WatchEventFluent.PodSecurityPolicyListObjectNested withNewPodSecurityPolicyListObjectLike(PodSecurityPolicyList item);
public A withReplicationControllerSpecObject(ReplicationControllerSpec replicationControllerSpecObject);
public WatchEventFluent.ReplicationControllerSpecObjectNested withNewReplicationControllerSpecObject();
public WatchEventFluent.ReplicationControllerSpecObjectNested withNewReplicationControllerSpecObjectLike(ReplicationControllerSpec item);
public A withPipelineConfigListObject(PipelineConfigList pipelineConfigListObject);
public WatchEventFluent.PipelineConfigListObjectNested withNewPipelineConfigListObject();
public WatchEventFluent.PipelineConfigListObjectNested withNewPipelineConfigListObjectLike(PipelineConfigList item);
public A withPipelineHookHTTPRequestObject(PipelineHookHTTPRequest pipelineHookHTTPRequestObject);
public WatchEventFluent.PipelineHookHTTPRequestObjectNested withNewPipelineHookHTTPRequestObject();
public WatchEventFluent.PipelineHookHTTPRequestObjectNested withNewPipelineHookHTTPRequestObjectLike(PipelineHookHTTPRequest item);
public A withResourceFieldSelectorObject(ResourceFieldSelector resourceFieldSelectorObject);
public WatchEventFluent.ResourceFieldSelectorObjectNested withNewResourceFieldSelectorObject();
public WatchEventFluent.ResourceFieldSelectorObjectNested withNewResourceFieldSelectorObjectLike(ResourceFieldSelector item);
public A withHostPathVolumeSourceObject(HostPathVolumeSource hostPathVolumeSourceObject);
public WatchEventFluent.HostPathVolumeSourceObjectNested withNewHostPathVolumeSourceObject();
public WatchEventFluent.HostPathVolumeSourceObjectNested withNewHostPathVolumeSourceObjectLike(HostPathVolumeSource item);
public A withNewHostPathVolumeSourceObject(String path);
public A withSELinuxStrategyOptionsObject(SELinuxStrategyOptions sELinuxStrategyOptionsObject);
public WatchEventFluent.SELinuxStrategyOptionsObjectNested withNewSELinuxStrategyOptionsObject();
public WatchEventFluent.SELinuxStrategyOptionsObjectNested withNewSELinuxStrategyOptionsObjectLike(SELinuxStrategyOptions item);
public A withPipelineConfigTemplateObject(PipelineConfigTemplate pipelineConfigTemplateObject);
public WatchEventFluent.PipelineConfigTemplateObjectNested withNewPipelineConfigTemplateObject();
public WatchEventFluent.PipelineConfigTemplateObjectNested withNewPipelineConfigTemplateObjectLike(PipelineConfigTemplate item);
public A withContainerStatusObject(ContainerStatus containerStatusObject);
public WatchEventFluent.ContainerStatusObjectNested withNewContainerStatusObject();
public WatchEventFluent.ContainerStatusObjectNested withNewContainerStatusObjectLike(ContainerStatus item);
public A withExecActionObject(ExecAction execActionObject);
public WatchEventFluent.ExecActionObjectNested withNewExecActionObject();
public WatchEventFluent.ExecActionObjectNested withNewExecActionObjectLike(ExecAction item);
public A withPreconditionsObject(Preconditions preconditionsObject);
public WatchEventFluent.PreconditionsObjectNested withNewPreconditionsObject();
public WatchEventFluent.PreconditionsObjectNested withNewPreconditionsObjectLike(Preconditions item);
public A withNewPreconditionsObject(String uid);
public A withOwnerInRepositoryObject(OwnerInRepository ownerInRepositoryObject);
public WatchEventFluent.OwnerInRepositoryObjectNested withNewOwnerInRepositoryObject();
public WatchEventFluent.OwnerInRepositoryObjectNested withNewOwnerInRepositoryObjectLike(OwnerInRepository item);
public A withNewOwnerInRepositoryObject(String id,String name,String type);
public A withClusterPipelineTemplateListObject(ClusterPipelineTemplateList clusterPipelineTemplateListObject);
public WatchEventFluent.ClusterPipelineTemplateListObjectNested withNewClusterPipelineTemplateListObject();
public WatchEventFluent.ClusterPipelineTemplateListObjectNested withNewClusterPipelineTemplateListObjectLike(ClusterPipelineTemplateList item);
public A withIngressRuleObject(IngressRule ingressRuleObject);
public WatchEventFluent.IngressRuleObjectNested withNewIngressRuleObject();
public WatchEventFluent.IngressRuleObjectNested withNewIngressRuleObjectLike(IngressRule item);
public A withStatefulSetStatusObject(StatefulSetStatus statefulSetStatusObject);
public WatchEventFluent.StatefulSetStatusObjectNested withNewStatefulSetStatusObject();
public WatchEventFluent.StatefulSetStatusObjectNested withNewStatefulSetStatusObjectLike(StatefulSetStatus item);
public A withNamespaceObject(Namespace namespaceObject);
public WatchEventFluent.NamespaceObjectNested withNewNamespaceObject();
public WatchEventFluent.NamespaceObjectNested withNewNamespaceObjectLike(Namespace item);
public A withNodeSelectorObject(NodeSelector nodeSelectorObject);
public WatchEventFluent.NodeSelectorObjectNested withNewNodeSelectorObject();
public WatchEventFluent.NodeSelectorObjectNested withNewNodeSelectorObjectLike(NodeSelector item);
public A withJenkinsfilePreviewOptionsObject(JenkinsfilePreviewOptions jenkinsfilePreviewOptionsObject);
public WatchEventFluent.JenkinsfilePreviewOptionsObjectNested withNewJenkinsfilePreviewOptionsObject();
public WatchEventFluent.JenkinsfilePreviewOptionsObjectNested withNewJenkinsfilePreviewOptionsObjectLike(JenkinsfilePreviewOptions item);
public A withPipelineListObject(PipelineList pipelineListObject);
public WatchEventFluent.PipelineListObjectNested withNewPipelineListObject();
public WatchEventFluent.PipelineListObjectNested withNewPipelineListObjectLike(PipelineList item);
public A withHTTPGetActionObject(HTTPGetAction hTTPGetActionObject);
public WatchEventFluent.HTTPGetActionObjectNested withNewHTTPGetActionObject();
public WatchEventFluent.HTTPGetActionObjectNested withNewHTTPGetActionObjectLike(HTTPGetAction item);
public A withEndpointsListObject(EndpointsList endpointsListObject);
public WatchEventFluent.EndpointsListObjectNested withNewEndpointsListObject();
public WatchEventFluent.EndpointsListObjectNested withNewEndpointsListObjectLike(EndpointsList item);
public A withJenkinsfilePreviewObject(JenkinsfilePreview jenkinsfilePreviewObject);
public WatchEventFluent.JenkinsfilePreviewObjectNested withNewJenkinsfilePreviewObject();
public WatchEventFluent.JenkinsfilePreviewObjectNested withNewJenkinsfilePreviewObjectLike(JenkinsfilePreview item);
public A withNewJenkinsfilePreviewObject(String apiVersion,String jenkinsfile,String kind);
public A withReplicationControllerStatusObject(ReplicationControllerStatus replicationControllerStatusObject);
public WatchEventFluent.ReplicationControllerStatusObjectNested withNewReplicationControllerStatusObject();
public WatchEventFluent.ReplicationControllerStatusObjectNested withNewReplicationControllerStatusObjectLike(ReplicationControllerStatus item);
public A withPipelineConfigObject(PipelineConfig pipelineConfigObject);
public WatchEventFluent.PipelineConfigObjectNested withNewPipelineConfigObject();
public WatchEventFluent.PipelineConfigObjectNested withNewPipelineConfigObjectLike(PipelineConfig item);
public A withTolerationObject(Toleration tolerationObject);
public WatchEventFluent.TolerationObjectNested withNewTolerationObject();
public WatchEventFluent.TolerationObjectNested withNewTolerationObjectLike(Toleration item);
public A withNewTolerationObject(String effect,String key,String operator,Long tolerationSeconds,String value);
public A withCodeRepoServiceObject(CodeRepoService codeRepoServiceObject);
public WatchEventFluent.CodeRepoServiceObjectNested withNewCodeRepoServiceObject();
public WatchEventFluent.CodeRepoServiceObjectNested withNewCodeRepoServiceObjectLike(CodeRepoService item);
public A withPipelineTaskArgumentValidationObject(PipelineTaskArgumentValidation pipelineTaskArgumentValidationObject);
public WatchEventFluent.PipelineTaskArgumentValidationObjectNested withNewPipelineTaskArgumentValidationObject();
public WatchEventFluent.PipelineTaskArgumentValidationObjectNested withNewPipelineTaskArgumentValidationObjectLike(PipelineTaskArgumentValidation item);
public A withNewPipelineTaskArgumentValidationObject(String pattern);
public A withAttachedVolumeObject(AttachedVolume attachedVolumeObject);
public WatchEventFluent.AttachedVolumeObjectNested withNewAttachedVolumeObject();
public WatchEventFluent.AttachedVolumeObjectNested withNewAttachedVolumeObjectLike(AttachedVolume item);
public A withNewAttachedVolumeObject(String devicePath,String name);
public A withStatefulSetListObject(StatefulSetList statefulSetListObject);
public WatchEventFluent.StatefulSetListObjectNested withNewStatefulSetListObject();
public WatchEventFluent.StatefulSetListObjectNested withNewStatefulSetListObjectLike(StatefulSetList item);
public A withJenkinsStatusObject(JenkinsStatus jenkinsStatusObject);
public WatchEventFluent.JenkinsStatusObjectNested withNewJenkinsStatusObject();
public WatchEventFluent.JenkinsStatusObjectNested withNewJenkinsStatusObjectLike(JenkinsStatus item);
public A withPipelineTriggerCodeChangeObject(PipelineTriggerCodeChange pipelineTriggerCodeChangeObject);
public WatchEventFluent.PipelineTriggerCodeChangeObjectNested withNewPipelineTriggerCodeChangeObject();
public WatchEventFluent.PipelineTriggerCodeChangeObjectNested withNewPipelineTriggerCodeChangeObjectLike(PipelineTriggerCodeChange item);
public A withNewPipelineTriggerCodeChangeObject(Boolean enabled,String periodicCheck);
public A withNamedExtensionObject(NamedExtension namedExtensionObject);
public WatchEventFluent.NamedExtensionObjectNested withNewNamedExtensionObject();
public WatchEventFluent.NamedExtensionObjectNested withNewNamedExtensionObjectLike(NamedExtension item);
public A withServiceListObject(ServiceList serviceListObject);
public WatchEventFluent.ServiceListObjectNested withNewServiceListObject();
public WatchEventFluent.ServiceListObjectNested withNewServiceListObjectLike(ServiceList item);
public A withIngressStatusObject(IngressStatus ingressStatusObject);
public WatchEventFluent.IngressStatusObjectNested withNewIngressStatusObject();
public WatchEventFluent.IngressStatusObjectNested withNewIngressStatusObjectLike(IngressStatus item);
public A withInitializersObject(Initializers initializersObject);
public WatchEventFluent.InitializersObjectNested withNewInitializersObject();
public WatchEventFluent.InitializersObjectNested withNewInitializersObjectLike(Initializers item);
public A withSecretKeySelectorObject(SecretKeySelector secretKeySelectorObject);
public WatchEventFluent.SecretKeySelectorObjectNested withNewSecretKeySelectorObject();
public WatchEventFluent.SecretKeySelectorObjectNested withNewSecretKeySelectorObjectLike(SecretKeySelector item);
public A withNewSecretKeySelectorObject(String key,String name,Boolean optional);
public A withPodConditionObject(PodCondition podConditionObject);
public WatchEventFluent.PodConditionObjectNested withNewPodConditionObject();
public WatchEventFluent.PodConditionObjectNested withNewPodConditionObjectLike(PodCondition item);
public A withSupplementalGroupsStrategyOptionsObject(SupplementalGroupsStrategyOptions supplementalGroupsStrategyOptionsObject);
public WatchEventFluent.SupplementalGroupsStrategyOptionsObjectNested withNewSupplementalGroupsStrategyOptionsObject();
public WatchEventFluent.SupplementalGroupsStrategyOptionsObjectNested withNewSupplementalGroupsStrategyOptionsObjectLike(SupplementalGroupsStrategyOptions item);
public A withContainerStateTerminatedObject(ContainerStateTerminated containerStateTerminatedObject);
public WatchEventFluent.ContainerStateTerminatedObjectNested withNewContainerStateTerminatedObject();
public WatchEventFluent.ContainerStateTerminatedObjectNested withNewContainerStateTerminatedObjectLike(ContainerStateTerminated item);
public A withHostPortStatusObject(HostPortStatus hostPortStatusObject);
public WatchEventFluent.HostPortStatusObjectNested withNewHostPortStatusObject();
public WatchEventFluent.HostPortStatusObjectNested withNewHostPortStatusObjectLike(HostPortStatus item);
public A withNewHostPortStatusObject(Long delay,String lastAttempt,String response,Integer statusCode,String version);
public A withReplicaSetSpecObject(ReplicaSetSpec replicaSetSpecObject);
public WatchEventFluent.ReplicaSetSpecObjectNested withNewReplicaSetSpecObject();
public WatchEventFluent.ReplicaSetSpecObjectNested withNewReplicaSetSpecObjectLike(ReplicaSetSpec item);
public A withPipelineSourceGitObject(PipelineSourceGit pipelineSourceGitObject);
public WatchEventFluent.PipelineSourceGitObjectNested withNewPipelineSourceGitObject();
public WatchEventFluent.PipelineSourceGitObjectNested withNewPipelineSourceGitObjectLike(PipelineSourceGit item);
public A withNewPipelineSourceGitObject(String ref,String uri);
public A withISCSIVolumeSourceObject(ISCSIVolumeSource iSCSIVolumeSourceObject);
public WatchEventFluent.ISCSIVolumeSourceObjectNested withNewISCSIVolumeSourceObject();
public WatchEventFluent.ISCSIVolumeSourceObjectNested withNewISCSIVolumeSourceObjectLike(ISCSIVolumeSource item);
public A withAzureDiskVolumeSourceObject(AzureDiskVolumeSource azureDiskVolumeSourceObject);
public WatchEventFluent.AzureDiskVolumeSourceObjectNested withNewAzureDiskVolumeSourceObject();
public WatchEventFluent.AzureDiskVolumeSourceObjectNested withNewAzureDiskVolumeSourceObjectLike(AzureDiskVolumeSource item);
public A withPipelineTaskArgumentWhenObject(PipelineTaskArgumentWhen pipelineTaskArgumentWhenObject);
public WatchEventFluent.PipelineTaskArgumentWhenObjectNested withNewPipelineTaskArgumentWhenObject();
public WatchEventFluent.PipelineTaskArgumentWhenObjectNested withNewPipelineTaskArgumentWhenObjectLike(PipelineTaskArgumentWhen item);
public A withNewPipelineTaskArgumentWhenObject(String name,Boolean value);
public A withDownwardAPIVolumeSourceObject(DownwardAPIVolumeSource downwardAPIVolumeSourceObject);
public WatchEventFluent.DownwardAPIVolumeSourceObjectNested withNewDownwardAPIVolumeSourceObject();
public WatchEventFluent.DownwardAPIVolumeSourceObjectNested withNewDownwardAPIVolumeSourceObjectLike(DownwardAPIVolumeSource item);
public A withStorageClassListObject(StorageClassList storageClassListObject);
public WatchEventFluent.StorageClassListObjectNested withNewStorageClassListObject();
public WatchEventFluent.StorageClassListObjectNested withNewStorageClassListObjectLike(StorageClassList item);
public A withGitRepoVolumeSourceObject(GitRepoVolumeSource gitRepoVolumeSourceObject);
public WatchEventFluent.GitRepoVolumeSourceObjectNested withNewGitRepoVolumeSourceObject();
public WatchEventFluent.GitRepoVolumeSourceObjectNested withNewGitRepoVolumeSourceObjectLike(GitRepoVolumeSource item);
public A withNewGitRepoVolumeSourceObject(String directory,String repository,String revision);
public A withCodeRepositoryRefObject(CodeRepositoryRef codeRepositoryRefObject);
public WatchEventFluent.CodeRepositoryRefObjectNested withNewCodeRepositoryRefObject();
public WatchEventFluent.CodeRepositoryRefObjectNested withNewCodeRepositoryRefObjectLike(CodeRepositoryRef item);
public A withNewCodeRepositoryRefObject(String name,String ref);
public A withPodTemplateSpecObject(PodTemplateSpec podTemplateSpecObject);
public WatchEventFluent.PodTemplateSpecObjectNested withNewPodTemplateSpecObject();
public WatchEventFluent.PodTemplateSpecObjectNested withNewPodTemplateSpecObjectLike(PodTemplateSpec item);
public A withJenkinsSpecObject(JenkinsSpec jenkinsSpecObject);
public WatchEventFluent.JenkinsSpecObjectNested withNewJenkinsSpecObject();
public WatchEventFluent.JenkinsSpecObjectNested withNewJenkinsSpecObjectLike(JenkinsSpec item);
public A withPipelineTemplateTaskInstanceSpecObject(PipelineTemplateTaskInstanceSpec pipelineTemplateTaskInstanceSpecObject);
public WatchEventFluent.PipelineTemplateTaskInstanceSpecObjectNested withNewPipelineTemplateTaskInstanceSpecObject();
public WatchEventFluent.PipelineTemplateTaskInstanceSpecObjectNested withNewPipelineTemplateTaskInstanceSpecObjectLike(PipelineTemplateTaskInstanceSpec item);
public A withContainerStateRunningObject(ContainerStateRunning containerStateRunningObject);
public WatchEventFluent.ContainerStateRunningObjectNested withNewContainerStateRunningObject();
public WatchEventFluent.ContainerStateRunningObjectNested withNewContainerStateRunningObjectLike(ContainerStateRunning item);
public A withNewContainerStateRunningObject(String startedAt);
public A withOwnerReferenceObject(OwnerReference ownerReferenceObject);
public WatchEventFluent.OwnerReferenceObjectNested withNewOwnerReferenceObject();
public WatchEventFluent.OwnerReferenceObjectNested withNewOwnerReferenceObjectLike(OwnerReference item);
public A withConfigMapVolumeSourceObject(ConfigMapVolumeSource configMapVolumeSourceObject);
public WatchEventFluent.ConfigMapVolumeSourceObjectNested withNewConfigMapVolumeSourceObject();
public WatchEventFluent.ConfigMapVolumeSourceObjectNested withNewConfigMapVolumeSourceObjectLike(ConfigMapVolumeSource item);
public A withLabelSelectorRequirementObject(LabelSelectorRequirement labelSelectorRequirementObject);
public WatchEventFluent.LabelSelectorRequirementObjectNested withNewLabelSelectorRequirementObject();
public WatchEventFluent.LabelSelectorRequirementObjectNested withNewLabelSelectorRequirementObjectLike(LabelSelectorRequirement item);
public A withJenkinsInstanceObject(JenkinsInstance jenkinsInstanceObject);
public WatchEventFluent.JenkinsInstanceObjectNested withNewJenkinsInstanceObject();
public WatchEventFluent.JenkinsInstanceObjectNested withNewJenkinsInstanceObjectLike(JenkinsInstance item);
public A withNewJenkinsInstanceObject(String name);
public A withResourceAttributesObject(ResourceAttributes resourceAttributesObject);
public WatchEventFluent.ResourceAttributesObjectNested withNewResourceAttributesObject();
public WatchEventFluent.ResourceAttributesObjectNested withNewResourceAttributesObjectLike(ResourceAttributes item);
public A withFlockerVolumeSourceObject(FlockerVolumeSource flockerVolumeSourceObject);
public WatchEventFluent.FlockerVolumeSourceObjectNested withNewFlockerVolumeSourceObject();
public WatchEventFluent.FlockerVolumeSourceObjectNested withNewFlockerVolumeSourceObjectLike(FlockerVolumeSource item);
public A withNewFlockerVolumeSourceObject(String datasetName,String datasetUUID);
public A withPodAntiAffinityObject(PodAntiAffinity podAntiAffinityObject);
public WatchEventFluent.PodAntiAffinityObjectNested withNewPodAntiAffinityObject();
public WatchEventFluent.PodAntiAffinityObjectNested withNewPodAntiAffinityObjectLike(PodAntiAffinity item);
public A withNamedContextObject(NamedContext namedContextObject);
public WatchEventFluent.NamedContextObjectNested withNewNamedContextObject();
public WatchEventFluent.NamedContextObjectNested withNewNamedContextObjectLike(NamedContext item);
public A withEnvVarObject(EnvVar envVarObject);
public WatchEventFluent.EnvVarObjectNested withNewEnvVarObject();
public WatchEventFluent.EnvVarObjectNested withNewEnvVarObjectLike(EnvVar item);
public A withScaleIOVolumeSourceObject(ScaleIOVolumeSource scaleIOVolumeSourceObject);
public WatchEventFluent.ScaleIOVolumeSourceObjectNested withNewScaleIOVolumeSourceObject();
public WatchEventFluent.ScaleIOVolumeSourceObjectNested withNewScaleIOVolumeSourceObjectLike(ScaleIOVolumeSource item);
public A withMultiBranchPipelineObject(MultiBranchPipeline multiBranchPipelineObject);
public WatchEventFluent.MultiBranchPipelineObjectNested withNewMultiBranchPipelineObject();
public WatchEventFluent.MultiBranchPipelineObjectNested withNewMultiBranchPipelineObjectLike(MultiBranchPipeline item);
public A withHandlerObject(Handler handlerObject);
public WatchEventFluent.HandlerObjectNested withNewHandlerObject();
public WatchEventFluent.HandlerObjectNested withNewHandlerObjectLike(Handler item);
public A withServiceStatusObject(ServiceStatus serviceStatusObject);
public WatchEventFluent.ServiceStatusObjectNested withNewServiceStatusObject();
public WatchEventFluent.ServiceStatusObjectNested withNewServiceStatusObjectLike(ServiceStatus item);
public A withIDRangeObject(IDRange iDRangeObject);
public WatchEventFluent.IDRangeObjectNested withNewIDRangeObject();
public WatchEventFluent.IDRangeObjectNested withNewIDRangeObjectLike(IDRange item);
public A withNewIDRangeObject(Long max,Long min);
public A withHorizontalPodAutoscalerListObject(HorizontalPodAutoscalerList horizontalPodAutoscalerListObject);
public WatchEventFluent.HorizontalPodAutoscalerListObjectNested withNewHorizontalPodAutoscalerListObject();
public WatchEventFluent.HorizontalPodAutoscalerListObjectNested withNewHorizontalPodAutoscalerListObjectLike(HorizontalPodAutoscalerList item);
public A withReplicaSetConditionObject(ReplicaSetCondition replicaSetConditionObject);
public WatchEventFluent.ReplicaSetConditionObjectNested withNewReplicaSetConditionObject();
public WatchEventFluent.ReplicaSetConditionObjectNested withNewReplicaSetConditionObjectLike(ReplicaSetCondition item);
public A withNewReplicaSetConditionObject(String lastTransitionTime,String message,String reason,String status,String type);
public A withPipelineSourceObject(PipelineSource pipelineSourceObject);
public WatchEventFluent.PipelineSourceObjectNested withNewPipelineSourceObject();
public WatchEventFluent.PipelineSourceObjectNested withNewPipelineSourceObjectLike(PipelineSource item);
public A withPodStatusObject(PodStatus podStatusObject);
public WatchEventFluent.PodStatusObjectNested withNewPodStatusObject();
public WatchEventFluent.PodStatusObjectNested withNewPodStatusObjectLike(PodStatus item);
public A withAuthProviderConfigObject(AuthProviderConfig authProviderConfigObject);
public WatchEventFluent.AuthProviderConfigObjectNested withNewAuthProviderConfigObject();
public WatchEventFluent.AuthProviderConfigObjectNested withNewAuthProviderConfigObjectLike(AuthProviderConfig item);
public A withJenkinsPluginObject(JenkinsPlugin jenkinsPluginObject);
public WatchEventFluent.JenkinsPluginObjectNested withNewJenkinsPluginObject();
public WatchEventFluent.JenkinsPluginObjectNested withNewJenkinsPluginObjectLike(JenkinsPlugin item);
public A withNewJenkinsPluginObject(String name,String version);
public A withGCEPersistentDiskVolumeSourceObject(GCEPersistentDiskVolumeSource gCEPersistentDiskVolumeSourceObject);
public WatchEventFluent.GCEPersistentDiskVolumeSourceObjectNested withNewGCEPersistentDiskVolumeSourceObject();
public WatchEventFluent.GCEPersistentDiskVolumeSourceObjectNested withNewGCEPersistentDiskVolumeSourceObjectLike(GCEPersistentDiskVolumeSource item);
public A withNewGCEPersistentDiskVolumeSourceObject(String fsType,Integer partition,String pdName,Boolean readOnly);
public A withEmptyDirVolumeSourceObject(EmptyDirVolumeSource emptyDirVolumeSourceObject);
public WatchEventFluent.EmptyDirVolumeSourceObjectNested withNewEmptyDirVolumeSourceObject();
public WatchEventFluent.EmptyDirVolumeSourceObjectNested withNewEmptyDirVolumeSourceObjectLike(EmptyDirVolumeSource item);
public A withCodeRepoBindingObject(CodeRepoBinding codeRepoBindingObject);
public WatchEventFluent.CodeRepoBindingObjectNested withNewCodeRepoBindingObject();
public WatchEventFluent.CodeRepoBindingObjectNested withNewCodeRepoBindingObjectLike(CodeRepoBinding item);
public A withPipelineTemplateTaskObject(PipelineTemplateTask pipelineTemplateTaskObject);
public WatchEventFluent.PipelineTemplateTaskObjectNested withNewPipelineTemplateTaskObject();
public WatchEventFluent.PipelineTemplateTaskObjectNested withNewPipelineTemplateTaskObjectLike(PipelineTemplateTask item);
public A withScaleObject(Scale scaleObject);
public WatchEventFluent.ScaleObjectNested withNewScaleObject();
public WatchEventFluent.ScaleObjectNested withNewScaleObjectLike(Scale item);
public A withPipelineTaskTemplateObject(PipelineTaskTemplate pipelineTaskTemplateObject);
public WatchEventFluent.PipelineTaskTemplateObjectNested withNewPipelineTaskTemplateObject();
public WatchEventFluent.PipelineTaskTemplateObjectNested withNewPipelineTaskTemplateObjectLike(PipelineTaskTemplate item);
public A withPodSpecObject(PodSpec podSpecObject);
public WatchEventFluent.PodSpecObjectNested withNewPodSpecObject();
public WatchEventFluent.PodSpecObjectNested withNewPodSpecObjectLike(PodSpec item);
public A withNodeSpecObject(NodeSpec nodeSpecObject);
public WatchEventFluent.NodeSpecObjectNested withNewNodeSpecObject();
public WatchEventFluent.NodeSpecObjectNested withNewNodeSpecObjectLike(NodeSpec item);
public A withPipelineConfigSpecObject(PipelineConfigSpec pipelineConfigSpecObject);
public WatchEventFluent.PipelineConfigSpecObjectNested withNewPipelineConfigSpecObject();
public WatchEventFluent.PipelineConfigSpecObjectNested withNewPipelineConfigSpecObjectLike(PipelineConfigSpec item);
public A withComponentConditionObject(ComponentCondition componentConditionObject);
public WatchEventFluent.ComponentConditionObjectNested withNewComponentConditionObject();
public WatchEventFluent.ComponentConditionObjectNested withNewComponentConditionObjectLike(ComponentCondition item);
public A withNewComponentConditionObject(String error,String message,String status,String type);
public A withPodObject(Pod podObject);
public WatchEventFluent.PodObjectNested withNewPodObject();
public WatchEventFluent.PodObjectNested withNewPodObjectLike(Pod item);
public A withCephFSVolumeSourceObject(CephFSVolumeSource cephFSVolumeSourceObject);
public WatchEventFluent.CephFSVolumeSourceObjectNested withNewCephFSVolumeSourceObject();
public WatchEventFluent.CephFSVolumeSourceObjectNested withNewCephFSVolumeSourceObjectLike(CephFSVolumeSource item);
public A withCodeRepositoryOwnerSyncObject(CodeRepositoryOwnerSync codeRepositoryOwnerSyncObject);
public WatchEventFluent.CodeRepositoryOwnerSyncObjectNested withNewCodeRepositoryOwnerSyncObject();
public WatchEventFluent.CodeRepositoryOwnerSyncObjectNested withNewCodeRepositoryOwnerSyncObjectLike(CodeRepositoryOwnerSync item);
public A withReplicationControllerConditionObject(ReplicationControllerCondition replicationControllerConditionObject);
public WatchEventFluent.ReplicationControllerConditionObjectNested withNewReplicationControllerConditionObject();
public WatchEventFluent.ReplicationControllerConditionObjectNested withNewReplicationControllerConditionObjectLike(ReplicationControllerCondition item);
public A withNewReplicationControllerConditionObject(String lastTransitionTime,String message,String reason,String status,String type);
public A withHorizontalPodAutoscalerObject(HorizontalPodAutoscaler horizontalPodAutoscalerObject);
public WatchEventFluent.HorizontalPodAutoscalerObjectNested withNewHorizontalPodAutoscalerObject();
public WatchEventFluent.HorizontalPodAutoscalerObjectNested withNewHorizontalPodAutoscalerObjectLike(HorizontalPodAutoscaler item);
public A withConfigMapProjectionObject(ConfigMapProjection configMapProjectionObject);
public WatchEventFluent.ConfigMapProjectionObjectNested withNewConfigMapProjectionObject();
public WatchEventFluent.ConfigMapProjectionObjectNested withNewConfigMapProjectionObjectLike(ConfigMapProjection item);
public A withCrossVersionObjectReferenceObject(CrossVersionObjectReference crossVersionObjectReferenceObject);
public WatchEventFluent.CrossVersionObjectReferenceObjectNested withNewCrossVersionObjectReferenceObject();
public WatchEventFluent.CrossVersionObjectReferenceObjectNested withNewCrossVersionObjectReferenceObjectLike(CrossVersionObjectReference item);
public A withNewCrossVersionObjectReferenceObject(String apiVersion,String kind,String name);
public A withClusterObject(Cluster clusterObject);
public WatchEventFluent.ClusterObjectNested withNewClusterObject();
public WatchEventFluent.ClusterObjectNested withNewClusterObjectLike(Cluster item);
public A withPersistentVolumeClaimStatusObject(PersistentVolumeClaimStatus persistentVolumeClaimStatusObject);
public WatchEventFluent.PersistentVolumeClaimStatusObjectNested withNewPersistentVolumeClaimStatusObject();
public WatchEventFluent.PersistentVolumeClaimStatusObjectNested withNewPersistentVolumeClaimStatusObjectLike(PersistentVolumeClaimStatus item);
public A withNetworkPolicyIngressRuleObject(NetworkPolicyIngressRule networkPolicyIngressRuleObject);
public WatchEventFluent.NetworkPolicyIngressRuleObjectNested withNewNetworkPolicyIngressRuleObject();
public WatchEventFluent.NetworkPolicyIngressRuleObjectNested withNewNetworkPolicyIngressRuleObjectLike(NetworkPolicyIngressRule item);
public A withLimitRangeListObject(LimitRangeList limitRangeListObject);
public WatchEventFluent.LimitRangeListObjectNested withNewLimitRangeListObject();
public WatchEventFluent.LimitRangeListObjectNested withNewLimitRangeListObjectLike(LimitRangeList item);
public A withEndpointAddressObject(EndpointAddress endpointAddressObject);
public WatchEventFluent.EndpointAddressObjectNested withNewEndpointAddressObject();
public WatchEventFluent.EndpointAddressObjectNested withNewEndpointAddressObjectLike(EndpointAddress item);
public A withProbeObject(Probe probeObject);
public WatchEventFluent.ProbeObjectNested withNewProbeObject();
public WatchEventFluent.ProbeObjectNested withNewProbeObjectLike(Probe item);
public A withConfigMapKeySelectorObject(ConfigMapKeySelector configMapKeySelectorObject);
public WatchEventFluent.ConfigMapKeySelectorObjectNested withNewConfigMapKeySelectorObject();
public WatchEventFluent.ConfigMapKeySelectorObjectNested withNewConfigMapKeySelectorObjectLike(ConfigMapKeySelector item);
public A withNewConfigMapKeySelectorObject(String key,String name,Boolean optional);
public A withPipelineTemplateArgumentGroupObject(PipelineTemplateArgumentGroup pipelineTemplateArgumentGroupObject);
public WatchEventFluent.PipelineTemplateArgumentGroupObjectNested withNewPipelineTemplateArgumentGroupObject();
public WatchEventFluent.PipelineTemplateArgumentGroupObjectNested withNewPipelineTemplateArgumentGroupObjectLike(PipelineTemplateArgumentGroup item);
public A withPipelineTaskTemplateSpecObject(PipelineTaskTemplateSpec pipelineTaskTemplateSpecObject);
public WatchEventFluent.PipelineTaskTemplateSpecObjectNested withNewPipelineTaskTemplateSpecObject();
public WatchEventFluent.PipelineTaskTemplateSpecObjectNested withNewPipelineTaskTemplateSpecObjectLike(PipelineTaskTemplateSpec item);
public A withCodeRepoServiceListObject(CodeRepoServiceList codeRepoServiceListObject);
public WatchEventFluent.CodeRepoServiceListObjectNested withNewCodeRepoServiceListObject();
public WatchEventFluent.CodeRepoServiceListObjectNested withNewCodeRepoServiceListObjectLike(CodeRepoServiceList item);
public A withPodAffinityTermObject(PodAffinityTerm podAffinityTermObject);
public WatchEventFluent.PodAffinityTermObjectNested withNewPodAffinityTermObject();
public WatchEventFluent.PodAffinityTermObjectNested withNewPodAffinityTermObjectLike(PodAffinityTerm item);
public A withJobListObject(JobList jobListObject);
public WatchEventFluent.JobListObjectNested withNewJobListObject();
public WatchEventFluent.JobListObjectNested withNewJobListObjectLike(JobList item);
public A withGlusterfsVolumeSourceObject(GlusterfsVolumeSource glusterfsVolumeSourceObject);
public WatchEventFluent.GlusterfsVolumeSourceObjectNested withNewGlusterfsVolumeSourceObject();
public WatchEventFluent.GlusterfsVolumeSourceObjectNested withNewGlusterfsVolumeSourceObjectLike(GlusterfsVolumeSource item);
public A withNewGlusterfsVolumeSourceObject(String endpoints,String path,Boolean readOnly);
public A withThirdPartyResourceObject(ThirdPartyResource thirdPartyResourceObject);
public WatchEventFluent.ThirdPartyResourceObjectNested withNewThirdPartyResourceObject();
public WatchEventFluent.ThirdPartyResourceObjectNested withNewThirdPartyResourceObjectLike(ThirdPartyResource item);
public A withPortworxVolumeSourceObject(PortworxVolumeSource portworxVolumeSourceObject);
public WatchEventFluent.PortworxVolumeSourceObjectNested withNewPortworxVolumeSourceObject();
public WatchEventFluent.PortworxVolumeSourceObjectNested withNewPortworxVolumeSourceObjectLike(PortworxVolumeSource item);
public A withNewPortworxVolumeSourceObject(String fsType,Boolean readOnly,String volumeID);
public A withCronJobListObject(CronJobList cronJobListObject);
public WatchEventFluent.CronJobListObjectNested withNewCronJobListObject();
public WatchEventFluent.CronJobListObjectNested withNewCronJobListObjectLike(CronJobList item);
public A withRBDVolumeSourceObject(RBDVolumeSource rBDVolumeSourceObject);
public WatchEventFluent.RBDVolumeSourceObjectNested withNewRBDVolumeSourceObject();
public WatchEventFluent.RBDVolumeSourceObjectNested withNewRBDVolumeSourceObjectLike(RBDVolumeSource item);
public A withPipelineHookObject(PipelineHook pipelineHookObject);
public WatchEventFluent.PipelineHookObjectNested withNewPipelineHookObject();
public WatchEventFluent.PipelineHookObjectNested withNewPipelineHookObjectLike(PipelineHook item);
public A withCronJobStatusObject(CronJobStatus cronJobStatusObject);
public WatchEventFluent.CronJobStatusObjectNested withNewCronJobStatusObject();
public WatchEventFluent.CronJobStatusObjectNested withNewCronJobStatusObjectLike(CronJobStatus item);
public A withStorageOSVolumeSourceObject(StorageOSVolumeSource storageOSVolumeSourceObject);
public WatchEventFluent.StorageOSVolumeSourceObjectNested withNewStorageOSVolumeSourceObject();
public WatchEventFluent.StorageOSVolumeSourceObjectNested withNewStorageOSVolumeSourceObjectLike(StorageOSVolumeSource item);
public A withServiceAccountListObject(ServiceAccountList serviceAccountListObject);
public WatchEventFluent.ServiceAccountListObjectNested withNewServiceAccountListObject();
public WatchEventFluent.ServiceAccountListObjectNested withNewServiceAccountListObjectLike(ServiceAccountList item);
public A withComponentStatusObject(ComponentStatus componentStatusObject);
public WatchEventFluent.ComponentStatusObjectNested withNewComponentStatusObject();
public WatchEventFluent.ComponentStatusObjectNested withNewComponentStatusObjectLike(ComponentStatus item);
public A withThirdPartyResourceListObject(ThirdPartyResourceList thirdPartyResourceListObject);
public WatchEventFluent.ThirdPartyResourceListObjectNested withNewThirdPartyResourceListObject();
public WatchEventFluent.ThirdPartyResourceListObjectNested withNewThirdPartyResourceListObjectLike(ThirdPartyResourceList item);
public A withProjectedVolumeSourceObject(ProjectedVolumeSource projectedVolumeSourceObject);
public WatchEventFluent.ProjectedVolumeSourceObjectNested withNewProjectedVolumeSourceObject();
public WatchEventFluent.ProjectedVolumeSourceObjectNested withNewProjectedVolumeSourceObjectLike(ProjectedVolumeSource item);
public A withHostPortObject(HostPort hostPortObject);
public WatchEventFluent.HostPortObjectNested withNewHostPortObject();
public WatchEventFluent.HostPortObjectNested withNewHostPortObjectLike(HostPort item);
public A withNewHostPortObject(String host);
public A withIngressBackendObject(IngressBackend ingressBackendObject);
public WatchEventFluent.IngressBackendObjectNested withNewIngressBackendObject();
public WatchEventFluent.IngressBackendObjectNested withNewIngressBackendObjectLike(IngressBackend item);
public A withPersistentVolumeClaimObject(PersistentVolumeClaim persistentVolumeClaimObject);
public WatchEventFluent.PersistentVolumeClaimObjectNested withNewPersistentVolumeClaimObject();
public WatchEventFluent.PersistentVolumeClaimObjectNested withNewPersistentVolumeClaimObjectLike(PersistentVolumeClaim item);
public A withPipelineDependencyObject(PipelineDependency pipelineDependencyObject);
public WatchEventFluent.PipelineDependencyObjectNested withNewPipelineDependencyObject();
public WatchEventFluent.PipelineDependencyObjectNested withNewPipelineDependencyObjectLike(PipelineDependency item);
public A withNetworkPolicyListObject(NetworkPolicyList networkPolicyListObject);
public WatchEventFluent.NetworkPolicyListObjectNested withNewNetworkPolicyListObject();
public WatchEventFluent.NetworkPolicyListObjectNested withNewNetworkPolicyListObjectLike(NetworkPolicyList item);
public A withResourceQuotaListObject(ResourceQuotaList resourceQuotaListObject);
public WatchEventFluent.ResourceQuotaListObjectNested withNewResourceQuotaListObject();
public WatchEventFluent.ResourceQuotaListObjectNested withNewResourceQuotaListObjectLike(ResourceQuotaList item);
public A withResourceRequirementsObject(ResourceRequirements resourceRequirementsObject);
public WatchEventFluent.ResourceRequirementsObjectNested withNewResourceRequirementsObject();
public WatchEventFluent.ResourceRequirementsObjectNested withNewResourceRequirementsObjectLike(ResourceRequirements item);
public A withSecretObject(Secret secretObject);
public WatchEventFluent.SecretObjectNested withNewSecretObject();
public WatchEventFluent.SecretObjectNested withNewSecretObjectLike(Secret item);
public A withJenkinsBindingSpecObject(JenkinsBindingSpec jenkinsBindingSpecObject);
public WatchEventFluent.JenkinsBindingSpecObjectNested withNewJenkinsBindingSpecObject();
public WatchEventFluent.JenkinsBindingSpecObjectNested withNewJenkinsBindingSpecObjectLike(JenkinsBindingSpec item);
public A withPodSecurityContextObject(PodSecurityContext podSecurityContextObject);
public WatchEventFluent.PodSecurityContextObjectNested withNewPodSecurityContextObject();
public WatchEventFluent.PodSecurityContextObjectNested withNewPodSecurityContextObjectLike(PodSecurityContext item);
public A withNodeSystemInfoObject(NodeSystemInfo nodeSystemInfoObject);
public WatchEventFluent.NodeSystemInfoObjectNested withNewNodeSystemInfoObject();
public WatchEventFluent.NodeSystemInfoObjectNested withNewNodeSystemInfoObjectLike(NodeSystemInfo item);
public A withReplicationControllerObject(ReplicationController replicationControllerObject);
public WatchEventFluent.ReplicationControllerObjectNested withNewReplicationControllerObject();
public WatchEventFluent.ReplicationControllerObjectNested withNewReplicationControllerObjectLike(ReplicationController item);
public A withCustomResourceDefinitionListObject(CustomResourceDefinitionList customResourceDefinitionListObject);
public WatchEventFluent.CustomResourceDefinitionListObjectNested withNewCustomResourceDefinitionListObject();
public WatchEventFluent.CustomResourceDefinitionListObjectNested withNewCustomResourceDefinitionListObjectLike(CustomResourceDefinitionList item);
public A withEndpointsObject(Endpoints endpointsObject);
public WatchEventFluent.EndpointsObjectNested withNewEndpointsObject();
public WatchEventFluent.EndpointsObjectNested withNewEndpointsObjectLike(Endpoints item);
public A withNodeSelectorRequirementObject(NodeSelectorRequirement nodeSelectorRequirementObject);
public WatchEventFluent.NodeSelectorRequirementObjectNested withNewNodeSelectorRequirementObject();
public WatchEventFluent.NodeSelectorRequirementObjectNested withNewNodeSelectorRequirementObjectLike(NodeSelectorRequirement item);
public A withLimitRangeObject(LimitRange limitRangeObject);
public WatchEventFluent.LimitRangeObjectNested withNewLimitRangeObject();
public WatchEventFluent.LimitRangeObjectNested withNewLimitRangeObjectLike(LimitRange item);
public A withLocalObjectReferenceObject(LocalObjectReference localObjectReferenceObject);
public WatchEventFluent.LocalObjectReferenceObjectNested withNewLocalObjectReferenceObject();
public WatchEventFluent.LocalObjectReferenceObjectNested withNewLocalObjectReferenceObjectLike(LocalObjectReference item);
public A withNewLocalObjectReferenceObject(String name);
public A withCustomResourceDefinitionConditionObject(CustomResourceDefinitionCondition customResourceDefinitionConditionObject);
public WatchEventFluent.CustomResourceDefinitionConditionObjectNested withNewCustomResourceDefinitionConditionObject();
public WatchEventFluent.CustomResourceDefinitionConditionObjectNested withNewCustomResourceDefinitionConditionObjectLike(CustomResourceDefinitionCondition item);
public A withNewCustomResourceDefinitionConditionObject(String lastTransitionTime,String message,String reason,String status,String type);
public A withRootPathsObject(RootPaths rootPathsObject);
public WatchEventFluent.RootPathsObjectNested withNewRootPathsObject();
public WatchEventFluent.RootPathsObjectNested withNewRootPathsObjectLike(RootPaths item);
public A withVsphereVirtualDiskVolumeSourceObject(VsphereVirtualDiskVolumeSource vsphereVirtualDiskVolumeSourceObject);
public WatchEventFluent.VsphereVirtualDiskVolumeSourceObjectNested withNewVsphereVirtualDiskVolumeSourceObject();
public WatchEventFluent.VsphereVirtualDiskVolumeSourceObjectNested withNewVsphereVirtualDiskVolumeSourceObjectLike(VsphereVirtualDiskVolumeSource item);
public A withNewVsphereVirtualDiskVolumeSourceObject(String fsType,String storagePolicyID,String storagePolicyName,String volumePath);
public A withDaemonEndpointObject(DaemonEndpoint daemonEndpointObject);
public WatchEventFluent.DaemonEndpointObjectNested withNewDaemonEndpointObject();
public WatchEventFluent.DaemonEndpointObjectNested withNewDaemonEndpointObjectLike(DaemonEndpoint item);
public A withNewDaemonEndpointObject(Integer port);
public A withKubernetesListObject(KubernetesList kubernetesListObject);
public WatchEventFluent.KubernetesListObjectNested withNewKubernetesListObject();
public WatchEventFluent.KubernetesListObjectNested withNewKubernetesListObjectLike(KubernetesList item);
public A withSecretKeySetRefObject(SecretKeySetRef secretKeySetRefObject);
public WatchEventFluent.SecretKeySetRefObjectNested withNewSecretKeySetRefObject();
public WatchEventFluent.SecretKeySetRefObjectNested withNewSecretKeySetRefObjectLike(SecretKeySetRef item);
public A withNewSecretKeySetRefObject(String apiTokenKey,String name,String namespace,String usernameKey);
public A withTokenReviewStatusObject(TokenReviewStatus tokenReviewStatusObject);
public WatchEventFluent.TokenReviewStatusObjectNested withNewTokenReviewStatusObject();
public WatchEventFluent.TokenReviewStatusObjectNested withNewTokenReviewStatusObjectLike(TokenReviewStatus item);
public A withCodeRepositoryStatusRepositoryObject(CodeRepositoryStatusRepository codeRepositoryStatusRepositoryObject);
public WatchEventFluent.CodeRepositoryStatusRepositoryObjectNested withNewCodeRepositoryStatusRepositoryObject();
public WatchEventFluent.CodeRepositoryStatusRepositoryObjectNested withNewCodeRepositoryStatusRepositoryObjectLike(CodeRepositoryStatusRepository item);
public A withEventSourceObject(EventSource eventSourceObject);
public WatchEventFluent.EventSourceObjectNested withNewEventSourceObject();
public WatchEventFluent.EventSourceObjectNested withNewEventSourceObjectLike(EventSource item);
public A withNewEventSourceObject(String component,String host);
public A withNetworkPolicyObject(NetworkPolicy networkPolicyObject);
public WatchEventFluent.NetworkPolicyObjectNested withNewNetworkPolicyObject();
public WatchEventFluent.NetworkPolicyObjectNested withNewNetworkPolicyObjectLike(NetworkPolicy item);
public A withContainerStateObject(ContainerState containerStateObject);
public WatchEventFluent.ContainerStateObjectNested withNewContainerStateObject();
public WatchEventFluent.ContainerStateObjectNested withNewContainerStateObjectLike(ContainerState item);
public A withAPIVersionObject(APIVersion aPIVersionObject);
public WatchEventFluent.APIVersionObjectNested withNewAPIVersionObject();
public WatchEventFluent.APIVersionObjectNested withNewAPIVersionObjectLike(APIVersion item);
public A withNewAPIVersionObject(String name);
public A withProjectNamespaceObject(ProjectNamespace projectNamespaceObject);
public WatchEventFluent.ProjectNamespaceObjectNested withNewProjectNamespaceObject();
public WatchEventFluent.ProjectNamespaceObjectNested withNewProjectNamespaceObjectLike(ProjectNamespace item);
public A withNewProjectNamespaceObject(String name,String type);
public A withProjectSpecObject(ProjectSpec projectSpecObject);
public WatchEventFluent.ProjectSpecObjectNested withNewProjectSpecObject();
public WatchEventFluent.ProjectSpecObjectNested withNewProjectSpecObjectLike(ProjectSpec item);
public A withHTTPHeaderObject(HTTPHeader hTTPHeaderObject);
public WatchEventFluent.HTTPHeaderObjectNested withNewHTTPHeaderObject();
public WatchEventFluent.HTTPHeaderObjectNested withNewHTTPHeaderObjectLike(HTTPHeader item);
public A withNewHTTPHeaderObject(String name,String value);
public A withServiceObject(Service serviceObject);
public WatchEventFluent.ServiceObjectNested withNewServiceObject();
public WatchEventFluent.ServiceObjectNested withNewServiceObjectLike(Service item);
public A withNetworkPolicyPortObject(NetworkPolicyPort networkPolicyPortObject);
public WatchEventFluent.NetworkPolicyPortObjectNested withNewNetworkPolicyPortObject();
public WatchEventFluent.NetworkPolicyPortObjectNested withNewNetworkPolicyPortObjectLike(NetworkPolicyPort item);
public A withIngressTLSObject(IngressTLS ingressTLSObject);
public WatchEventFluent.IngressTLSObjectNested withNewIngressTLSObject();
public WatchEventFluent.IngressTLSObjectNested withNewIngressTLSObjectLike(IngressTLS item);
public A withPipelineTemplateArgumentObject(PipelineTemplateArgument pipelineTemplateArgumentObject);
public WatchEventFluent.PipelineTemplateArgumentObjectNested withNewPipelineTemplateArgumentObject();
public WatchEventFluent.PipelineTemplateArgumentObjectNested withNewPipelineTemplateArgumentObjectLike(PipelineTemplateArgument item);
public A withVolumeProjectionObject(VolumeProjection volumeProjectionObject);
public WatchEventFluent.VolumeProjectionObjectNested withNewVolumeProjectionObject();
public WatchEventFluent.VolumeProjectionObjectNested withNewVolumeProjectionObjectLike(VolumeProjection item);
public A withPersistentVolumeSpecObject(PersistentVolumeSpec persistentVolumeSpecObject);
public WatchEventFluent.PersistentVolumeSpecObjectNested withNewPersistentVolumeSpecObject();
public WatchEventFluent.PersistentVolumeSpecObjectNested withNewPersistentVolumeSpecObjectLike(PersistentVolumeSpec item);
public A withSecretEnvSourceObject(SecretEnvSource secretEnvSourceObject);
public WatchEventFluent.SecretEnvSourceObjectNested withNewSecretEnvSourceObject();
public WatchEventFluent.SecretEnvSourceObjectNested withNewSecretEnvSourceObjectLike(SecretEnvSource item);
public A withNewSecretEnvSourceObject(String name,Boolean optional);
public A withNFSVolumeSourceObject(NFSVolumeSource nFSVolumeSourceObject);
public WatchEventFluent.NFSVolumeSourceObjectNested withNewNFSVolumeSourceObject();
public WatchEventFluent.NFSVolumeSourceObjectNested withNewNFSVolumeSourceObjectLike(NFSVolumeSource item);
public A withNewNFSVolumeSourceObject(String path,Boolean readOnly,String server);
public A withEventObject(Event eventObject);
public WatchEventFluent.EventObjectNested withNewEventObject();
public WatchEventFluent.EventObjectNested withNewEventObjectLike(Event item);
public A withObjectFieldSelectorObject(ObjectFieldSelector objectFieldSelectorObject);
public WatchEventFluent.ObjectFieldSelectorObjectNested withNewObjectFieldSelectorObject();
public WatchEventFluent.ObjectFieldSelectorObjectNested withNewObjectFieldSelectorObjectLike(ObjectFieldSelector item);
public A withNewObjectFieldSelectorObject(String apiVersion,String fieldPath);
public A withIngressSpecObject(IngressSpec ingressSpecObject);
public WatchEventFluent.IngressSpecObjectNested withNewIngressSpecObject();
public WatchEventFluent.IngressSpecObjectNested withNewIngressSpecObjectLike(IngressSpec item);
public A withNamespaceStatusObject(NamespaceStatus namespaceStatusObject);
public WatchEventFluent.NamespaceStatusObjectNested withNewNamespaceStatusObject();
public WatchEventFluent.NamespaceStatusObjectNested withNewNamespaceStatusObjectLike(NamespaceStatus item);
public A withNewNamespaceStatusObject(String phase);
public A withSecurityContextObject(SecurityContext securityContextObject);
public WatchEventFluent.SecurityContextObjectNested withNewSecurityContextObject();
public WatchEventFluent.SecurityContextObjectNested withNewSecurityContextObjectLike(SecurityContext item);
public A withJenkinsBindingStatusObject(JenkinsBindingStatus jenkinsBindingStatusObject);
public WatchEventFluent.JenkinsBindingStatusObjectNested withNewJenkinsBindingStatusObject();
public WatchEventFluent.JenkinsBindingStatusObjectNested withNewJenkinsBindingStatusObjectLike(JenkinsBindingStatus item);
public A withPodDisruptionBudgetSpecObject(PodDisruptionBudgetSpec podDisruptionBudgetSpecObject);
public WatchEventFluent.PodDisruptionBudgetSpecObjectNested withNewPodDisruptionBudgetSpecObject();
public WatchEventFluent.PodDisruptionBudgetSpecObjectNested withNewPodDisruptionBudgetSpecObjectLike(PodDisruptionBudgetSpec item);
public A withCodeRepositoryListObject(CodeRepositoryList codeRepositoryListObject);
public WatchEventFluent.CodeRepositoryListObjectNested withNewCodeRepositoryListObject();
public WatchEventFluent.CodeRepositoryListObjectNested withNewCodeRepositoryListObjectLike(CodeRepositoryList item);
public A withTaintObject(Taint taintObject);
public WatchEventFluent.TaintObjectNested withNewTaintObject();
public WatchEventFluent.TaintObjectNested withNewTaintObjectLike(Taint item);
public A withNewTaintObject(String effect,String key,String timeAdded,String value);
public A withPodSecurityPolicySpecObject(PodSecurityPolicySpec podSecurityPolicySpecObject);
public WatchEventFluent.PodSecurityPolicySpecObjectNested withNewPodSecurityPolicySpecObject();
public WatchEventFluent.PodSecurityPolicySpecObjectNested withNewPodSecurityPolicySpecObjectLike(PodSecurityPolicySpec item);
public A withCustomResourceDefinitionNamesObject(CustomResourceDefinitionNames customResourceDefinitionNamesObject);
public WatchEventFluent.CustomResourceDefinitionNamesObjectNested withNewCustomResourceDefinitionNamesObject();
public WatchEventFluent.CustomResourceDefinitionNamesObjectNested withNewCustomResourceDefinitionNamesObjectLike(CustomResourceDefinitionNames item);
public A withNodeObject(Node nodeObject);
public WatchEventFluent.NodeObjectNested withNewNodeObject();
public WatchEventFluent.NodeObjectNested withNewNodeObjectLike(Node item);
public A withInfoObject(Info infoObject);
public WatchEventFluent.InfoObjectNested withNewInfoObject();
public WatchEventFluent.InfoObjectNested withNewInfoObjectLike(Info item);
public A withTCPSocketActionObject(TCPSocketAction tCPSocketActionObject);
public WatchEventFluent.TCPSocketActionObjectNested withNewTCPSocketActionObject();
public WatchEventFluent.TCPSocketActionObjectNested withNewTCPSocketActionObjectLike(TCPSocketAction item);
public A withEnvFromSourceObject(EnvFromSource envFromSourceObject);
public WatchEventFluent.EnvFromSourceObjectNested withNewEnvFromSourceObject();
public WatchEventFluent.EnvFromSourceObjectNested withNewEnvFromSourceObjectLike(EnvFromSource item);
public A withKeyToPathObject(KeyToPath keyToPathObject);
public WatchEventFluent.KeyToPathObjectNested withNewKeyToPathObject();
public WatchEventFluent.KeyToPathObjectNested withNewKeyToPathObjectLike(KeyToPath item);
public A withNewKeyToPathObject(String key,Integer mode,String path);
public A withReplicaSetObject(ReplicaSet replicaSetObject);
public WatchEventFluent.ReplicaSetObjectNested withNewReplicaSetObject();
public WatchEventFluent.ReplicaSetObjectNested withNewReplicaSetObjectLike(ReplicaSet item);
public A withNodeSelectorTermObject(NodeSelectorTerm nodeSelectorTermObject);
public WatchEventFluent.NodeSelectorTermObjectNested withNewNodeSelectorTermObject();
public WatchEventFluent.NodeSelectorTermObjectNested withNewNodeSelectorTermObjectLike(NodeSelectorTerm item);
public A withSubjectAccessReviewStatusObject(SubjectAccessReviewStatus subjectAccessReviewStatusObject);
public WatchEventFluent.SubjectAccessReviewStatusObjectNested withNewSubjectAccessReviewStatusObject();
public WatchEventFluent.SubjectAccessReviewStatusObjectNested withNewSubjectAccessReviewStatusObjectLike(SubjectAccessReviewStatus item);
public A withNewSubjectAccessReviewStatusObject(Boolean allowed,String evaluationError,String reason);
public A withDeploymentListObject(DeploymentList deploymentListObject);
public WatchEventFluent.DeploymentListObjectNested withNewDeploymentListObject();
public WatchEventFluent.DeploymentListObjectNested withNewDeploymentListObjectLike(DeploymentList item);
public A withPersistentVolumeClaimSpecObject(PersistentVolumeClaimSpec persistentVolumeClaimSpecObject);
public WatchEventFluent.PersistentVolumeClaimSpecObjectNested withNewPersistentVolumeClaimSpecObject();
public WatchEventFluent.PersistentVolumeClaimSpecObjectNested withNewPersistentVolumeClaimSpecObjectLike(PersistentVolumeClaimSpec item);
public A withNamespaceSpecObject(NamespaceSpec namespaceSpecObject);
public WatchEventFluent.NamespaceSpecObjectNested withNewNamespaceSpecObject();
public WatchEventFluent.NamespaceSpecObjectNested withNewNamespaceSpecObjectLike(NamespaceSpec item);
public A withPipelineTaskArgumentDisplayObject(PipelineTaskArgumentDisplay pipelineTaskArgumentDisplayObject);
public WatchEventFluent.PipelineTaskArgumentDisplayObjectNested withNewPipelineTaskArgumentDisplayObject();
public WatchEventFluent.PipelineTaskArgumentDisplayObjectNested withNewPipelineTaskArgumentDisplayObjectLike(PipelineTaskArgumentDisplay item);
public A withEndpointSubsetObject(EndpointSubset endpointSubsetObject);
public WatchEventFluent.EndpointSubsetObjectNested withNewEndpointSubsetObject();
public WatchEventFluent.EndpointSubsetObjectNested withNewEndpointSubsetObjectLike(EndpointSubset item);
public A withPatchObject(Patch patchObject);
public WatchEventFluent.PatchObjectNested withNewPatchObject();
public WatchEventFluent.PatchObjectNested withNewPatchObjectLike(Patch item);
public A withJobTemplateSpecObject(JobTemplateSpec jobTemplateSpecObject);
public WatchEventFluent.JobTemplateSpecObjectNested withNewJobTemplateSpecObject();
public WatchEventFluent.JobTemplateSpecObjectNested withNewJobTemplateSpecObjectLike(JobTemplateSpec item);
public A withLoadBalancerStatusObject(LoadBalancerStatus loadBalancerStatusObject);
public WatchEventFluent.LoadBalancerStatusObjectNested withNewLoadBalancerStatusObject();
public WatchEventFluent.LoadBalancerStatusObjectNested withNewLoadBalancerStatusObjectLike(LoadBalancerStatus item);
public A withReplicaSetStatusObject(ReplicaSetStatus replicaSetStatusObject);
public WatchEventFluent.ReplicaSetStatusObjectNested withNewReplicaSetStatusObject();
public WatchEventFluent.ReplicaSetStatusObjectNested withNewReplicaSetStatusObjectLike(ReplicaSetStatus item);
public A withClusterPipelineTemplateObject(ClusterPipelineTemplate clusterPipelineTemplateObject);
public WatchEventFluent.ClusterPipelineTemplateObjectNested withNewClusterPipelineTemplateObject();
public WatchEventFluent.ClusterPipelineTemplateObjectNested withNewClusterPipelineTemplateObjectLike(ClusterPipelineTemplate item);
public A withPipelineConfigTemplateSpecObject(PipelineConfigTemplateSpec pipelineConfigTemplateSpecObject);
public WatchEventFluent.PipelineConfigTemplateSpecObjectNested withNewPipelineConfigTemplateSpecObject();
public WatchEventFluent.PipelineConfigTemplateSpecObjectNested withNewPipelineConfigTemplateSpecObjectLike(PipelineConfigTemplateSpec item);
public A withDaemonSetListObject(DaemonSetList daemonSetListObject);
public WatchEventFluent.DaemonSetListObjectNested withNewDaemonSetListObject();
public WatchEventFluent.DaemonSetListObjectNested withNewDaemonSetListObjectLike(DaemonSetList item);
public A withHorizontalPodAutoscalerStatusObject(HorizontalPodAutoscalerStatus horizontalPodAutoscalerStatusObject);
public WatchEventFluent.HorizontalPodAutoscalerStatusObjectNested withNewHorizontalPodAutoscalerStatusObject();
public WatchEventFluent.HorizontalPodAutoscalerStatusObjectNested withNewHorizontalPodAutoscalerStatusObjectLike(HorizontalPodAutoscalerStatus item);
public A withNewHorizontalPodAutoscalerStatusObject(Integer currentCPUUtilizationPercentage,Integer currentReplicas,Integer desiredReplicas,String lastScaleTime,Long observedGeneration);
public A withSubjectAccessReviewSpecObject(SubjectAccessReviewSpec subjectAccessReviewSpecObject);
public WatchEventFluent.SubjectAccessReviewSpecObjectNested withNewSubjectAccessReviewSpecObject();
public WatchEventFluent.SubjectAccessReviewSpecObjectNested withNewSubjectAccessReviewSpecObjectLike(SubjectAccessReviewSpec item);
public A withLifecycleObject(Lifecycle lifecycleObject);
public WatchEventFluent.LifecycleObjectNested withNewLifecycleObject();
public WatchEventFluent.LifecycleObjectNested withNewLifecycleObjectLike(Lifecycle item);
public A withJobObject(Job jobObject);
public WatchEventFluent.JobObjectNested withNewJobObject();
public WatchEventFluent.JobObjectNested withNewJobObjectLike(Job item);
public A withNamedAuthInfoObject(NamedAuthInfo namedAuthInfoObject);
public WatchEventFluent.NamedAuthInfoObjectNested withNewNamedAuthInfoObject();
public WatchEventFluent.NamedAuthInfoObjectNested withNewNamedAuthInfoObjectLike(NamedAuthInfo item);
public A withContainerImageObject(ContainerImage containerImageObject);
public WatchEventFluent.ContainerImageObjectNested withNewContainerImageObject();
public WatchEventFluent.ContainerImageObjectNested withNewContainerImageObjectLike(ContainerImage item);
public A withStatefulSetUpdateStrategyObject(StatefulSetUpdateStrategy statefulSetUpdateStrategyObject);
public WatchEventFluent.StatefulSetUpdateStrategyObjectNested withNewStatefulSetUpdateStrategyObject();
public WatchEventFluent.StatefulSetUpdateStrategyObjectNested withNewStatefulSetUpdateStrategyObjectLike(StatefulSetUpdateStrategy item);
public A withPipelineTriggerCronObject(PipelineTriggerCron pipelineTriggerCronObject);
public WatchEventFluent.PipelineTriggerCronObjectNested withNewPipelineTriggerCronObject();
public WatchEventFluent.PipelineTriggerCronObjectNested withNewPipelineTriggerCronObjectLike(PipelineTriggerCron item);
public A withNonResourceAttributesObject(NonResourceAttributes nonResourceAttributesObject);
public WatchEventFluent.NonResourceAttributesObjectNested withNewNonResourceAttributesObject();
public WatchEventFluent.NonResourceAttributesObjectNested withNewNonResourceAttributesObjectLike(NonResourceAttributes item);
public A withNewNonResourceAttributesObject(String path,String verb);
public A withObjectMetaObject(ObjectMeta objectMetaObject);
public WatchEventFluent.ObjectMetaObjectNested withNewObjectMetaObject();
public WatchEventFluent.ObjectMetaObjectNested withNewObjectMetaObjectLike(ObjectMeta item);
public A withEnvVarSourceObject(EnvVarSource envVarSourceObject);
public WatchEventFluent.EnvVarSourceObjectNested withNewEnvVarSourceObject();
public WatchEventFluent.EnvVarSourceObjectNested withNewEnvVarSourceObjectLike(EnvVarSource item);
public A withRollingUpdateDaemonSetObject(RollingUpdateDaemonSet rollingUpdateDaemonSetObject);
public WatchEventFluent.RollingUpdateDaemonSetObjectNested withNewRollingUpdateDaemonSetObject();
public WatchEventFluent.RollingUpdateDaemonSetObjectNested withNewRollingUpdateDaemonSetObjectLike(RollingUpdateDaemonSet item);
public A withPhotonPersistentDiskVolumeSourceObject(PhotonPersistentDiskVolumeSource photonPersistentDiskVolumeSourceObject);
public WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested withNewPhotonPersistentDiskVolumeSourceObject();
public WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested withNewPhotonPersistentDiskVolumeSourceObjectLike(PhotonPersistentDiskVolumeSource item);
public A withNewPhotonPersistentDiskVolumeSourceObject(String fsType,String pdID);
public A withReplicationControllerListObject(ReplicationControllerList replicationControllerListObject);
public WatchEventFluent.ReplicationControllerListObjectNested withNewReplicationControllerListObject();
public WatchEventFluent.ReplicationControllerListObjectNested withNewReplicationControllerListObjectLike(ReplicationControllerList item);
public A withHTTPIngressPathObject(HTTPIngressPath hTTPIngressPathObject);
public WatchEventFluent.HTTPIngressPathObjectNested withNewHTTPIngressPathObject();
public WatchEventFluent.HTTPIngressPathObjectNested withNewHTTPIngressPathObjectLike(HTTPIngressPath item);
public A withJobStatusObject(JobStatus jobStatusObject);
public WatchEventFluent.JobStatusObjectNested withNewJobStatusObject();
public WatchEventFluent.JobStatusObjectNested withNewJobStatusObjectLike(JobStatus item);
public A withDownwardAPIVolumeFileObject(DownwardAPIVolumeFile downwardAPIVolumeFileObject);
public WatchEventFluent.DownwardAPIVolumeFileObjectNested withNewDownwardAPIVolumeFileObject();
public WatchEventFluent.DownwardAPIVolumeFileObjectNested withNewDownwardAPIVolumeFileObjectLike(DownwardAPIVolumeFile item);
public A withRollbackConfigObject(RollbackConfig rollbackConfigObject);
public WatchEventFluent.RollbackConfigObjectNested withNewRollbackConfigObject();
public WatchEventFluent.RollbackConfigObjectNested withNewRollbackConfigObjectLike(RollbackConfig item);
public A withNewRollbackConfigObject(Long revision);
public A withCapabilitiesObject(Capabilities capabilitiesObject);
public WatchEventFluent.CapabilitiesObjectNested withNewCapabilitiesObject();
public WatchEventFluent.CapabilitiesObjectNested withNewCapabilitiesObjectLike(Capabilities item);
public A withPodAffinityObject(PodAffinity podAffinityObject);
public WatchEventFluent.PodAffinityObjectNested withNewPodAffinityObject();
public WatchEventFluent.PodAffinityObjectNested withNewPodAffinityObjectLike(PodAffinity item);
public A withServiceSpecObject(ServiceSpec serviceSpecObject);
public WatchEventFluent.ServiceSpecObjectNested withNewServiceSpecObject();
public WatchEventFluent.ServiceSpecObjectNested withNewServiceSpecObjectLike(ServiceSpec item);
public A withResourceQuotaStatusObject(ResourceQuotaStatus resourceQuotaStatusObject);
public WatchEventFluent.ResourceQuotaStatusObjectNested withNewResourceQuotaStatusObject();
public WatchEventFluent.ResourceQuotaStatusObjectNested withNewResourceQuotaStatusObjectLike(ResourceQuotaStatus item);
public A withClusterPipelineTaskTemplateObject(ClusterPipelineTaskTemplate clusterPipelineTaskTemplateObject);
public WatchEventFluent.ClusterPipelineTaskTemplateObjectNested withNewClusterPipelineTaskTemplateObject();
public WatchEventFluent.ClusterPipelineTaskTemplateObjectNested withNewClusterPipelineTaskTemplateObjectLike(ClusterPipelineTaskTemplate item);
public A withReplicaSetListObject(ReplicaSetList replicaSetListObject);
public WatchEventFluent.ReplicaSetListObjectNested withNewReplicaSetListObject();
public WatchEventFluent.ReplicaSetListObjectNested withNewReplicaSetListObjectLike(ReplicaSetList item);
public A withStatefulSetSpecObject(StatefulSetSpec statefulSetSpecObject);
public WatchEventFluent.StatefulSetSpecObjectNested withNewStatefulSetSpecObject();
public WatchEventFluent.StatefulSetSpecObjectNested withNewStatefulSetSpecObjectLike(StatefulSetSpec item);
public A withSecretProjectionObject(SecretProjection secretProjectionObject);
public WatchEventFluent.SecretProjectionObjectNested withNewSecretProjectionObject();
public WatchEventFluent.SecretProjectionObjectNested withNewSecretProjectionObjectLike(SecretProjection item);
public A withDeploymentObject(Deployment deploymentObject);
public WatchEventFluent.DeploymentObjectNested withNewDeploymentObject();
public WatchEventFluent.DeploymentObjectNested withNewDeploymentObjectLike(Deployment item);
public A withJobConditionObject(JobCondition jobConditionObject);
public WatchEventFluent.JobConditionObjectNested withNewJobConditionObject();
public WatchEventFluent.JobConditionObjectNested withNewJobConditionObjectLike(JobCondition item);
public A withPersistentVolumeClaimVolumeSourceObject(PersistentVolumeClaimVolumeSource persistentVolumeClaimVolumeSourceObject);
public WatchEventFluent.PersistentVolumeClaimVolumeSourceObjectNested withNewPersistentVolumeClaimVolumeSourceObject();
public WatchEventFluent.PersistentVolumeClaimVolumeSourceObjectNested withNewPersistentVolumeClaimVolumeSourceObjectLike(PersistentVolumeClaimVolumeSource item);
public A withNewPersistentVolumeClaimVolumeSourceObject(String claimName,Boolean readOnly);
public A withJenkinsObject(Jenkins jenkinsObject);
public WatchEventFluent.JenkinsObjectNested withNewJenkinsObject();
public WatchEventFluent.JenkinsObjectNested withNewJenkinsObjectLike(Jenkins item);
public A withDeploymentStrategyObject(DeploymentStrategy deploymentStrategyObject);
public WatchEventFluent.DeploymentStrategyObjectNested withNewDeploymentStrategyObject();
public WatchEventFluent.DeploymentStrategyObjectNested withNewDeploymentStrategyObjectLike(DeploymentStrategy item);
public A withContainerPortObject(ContainerPort containerPortObject);
public WatchEventFluent.ContainerPortObjectNested withNewContainerPortObject();
public WatchEventFluent.ContainerPortObjectNested withNewContainerPortObjectLike(ContainerPort item);
public A withNewContainerPortObject(Integer containerPort,String hostIP,Integer hostPort,String name,String protocol);
public A withNodeAddressObject(NodeAddress nodeAddressObject);
public WatchEventFluent.NodeAddressObjectNested withNewNodeAddressObject();
public WatchEventFluent.NodeAddressObjectNested withNewNodeAddressObjectLike(NodeAddress item);
public A withNewNodeAddressObject(String address,String type);
public A withPodTemplateListObject(PodTemplateList podTemplateListObject);
public WatchEventFluent.PodTemplateListObjectNested withNewPodTemplateListObject();
public WatchEventFluent.PodTemplateListObjectNested withNewPodTemplateListObjectLike(PodTemplateList item);
public A withPersistentVolumeStatusObject(PersistentVolumeStatus persistentVolumeStatusObject);
public WatchEventFluent.PersistentVolumeStatusObjectNested withNewPersistentVolumeStatusObject();
public WatchEventFluent.PersistentVolumeStatusObjectNested withNewPersistentVolumeStatusObjectLike(PersistentVolumeStatus item);
public A withNewPersistentVolumeStatusObject(String message,String phase,String reason);
public A withDaemonSetObject(DaemonSet daemonSetObject);
public WatchEventFluent.DaemonSetObjectNested withNewDaemonSetObject();
public WatchEventFluent.DaemonSetObjectNested withNewDaemonSetObjectLike(DaemonSet item);
public A withPodDisruptionBudgetObject(PodDisruptionBudget podDisruptionBudgetObject);
public WatchEventFluent.PodDisruptionBudgetObjectNested withNewPodDisruptionBudgetObject();
public WatchEventFluent.PodDisruptionBudgetObjectNested withNewPodDisruptionBudgetObjectLike(PodDisruptionBudget item);
public A withPipelineTaskArgumentActionObject(PipelineTaskArgumentAction pipelineTaskArgumentActionObject);
public WatchEventFluent.PipelineTaskArgumentActionObjectNested withNewPipelineTaskArgumentActionObject();
public WatchEventFluent.PipelineTaskArgumentActionObjectNested withNewPipelineTaskArgumentActionObjectLike(PipelineTaskArgumentAction item);
public A withProjectStatusObject(ProjectStatus projectStatusObject);
public WatchEventFluent.ProjectStatusObjectNested withNewProjectStatusObject();
public WatchEventFluent.ProjectStatusObjectNested withNewProjectStatusObjectLike(ProjectStatus item);
public A withPipelineSpecObject(PipelineSpec pipelineSpecObject);
public WatchEventFluent.PipelineSpecObjectNested withNewPipelineSpecObject();
public WatchEventFluent.PipelineSpecObjectNested withNewPipelineSpecObjectLike(PipelineSpec item);
public A withScaleStatusObject(ScaleStatus scaleStatusObject);
public WatchEventFluent.ScaleStatusObjectNested withNewScaleStatusObject();
public WatchEventFluent.ScaleStatusObjectNested withNewScaleStatusObjectLike(ScaleStatus item);
public A withProjectObject(Project projectObject);
public WatchEventFluent.ProjectObjectNested withNewProjectObject();
public WatchEventFluent.ProjectObjectNested withNewProjectObjectLike(Project item);
public A withPipelineTaskArgumentObject(PipelineTaskArgument pipelineTaskArgumentObject);
public WatchEventFluent.PipelineTaskArgumentObjectNested withNewPipelineTaskArgumentObject();
public WatchEventFluent.PipelineTaskArgumentObjectNested withNewPipelineTaskArgumentObjectLike(PipelineTaskArgument item);
public A withWatchEventObject(WatchEvent watchEventObject);
public WatchEventFluent.WatchEventObjectNested withNewWatchEventObject();
public WatchEventFluent.WatchEventObjectNested withNewWatchEventObjectLike(WatchEvent item);
public A withConfigMapEnvSourceObject(ConfigMapEnvSource configMapEnvSourceObject);
public WatchEventFluent.ConfigMapEnvSourceObjectNested withNewConfigMapEnvSourceObject();
public WatchEventFluent.ConfigMapEnvSourceObjectNested withNewConfigMapEnvSourceObjectLike(ConfigMapEnvSource item);
public A withNewConfigMapEnvSourceObject(String name,Boolean optional);
public A withHostAliasObject(HostAlias hostAliasObject);
public WatchEventFluent.HostAliasObjectNested withNewHostAliasObject();
public WatchEventFluent.HostAliasObjectNested withNewHostAliasObjectLike(HostAlias item);
public A withHTTPIngressRuleValueObject(HTTPIngressRuleValue hTTPIngressRuleValueObject);
public WatchEventFluent.HTTPIngressRuleValueObjectNested withNewHTTPIngressRuleValueObject();
public WatchEventFluent.HTTPIngressRuleValueObjectNested withNewHTTPIngressRuleValueObjectLike(HTTPIngressRuleValue item);
public A withEndpointPortObject(EndpointPort endpointPortObject);
public WatchEventFluent.EndpointPortObjectNested withNewEndpointPortObject();
public WatchEventFluent.EndpointPortObjectNested withNewEndpointPortObjectLike(EndpointPort item);
public A withNewEndpointPortObject(String name,Integer port,String protocol);
public A withStatusCauseObject(StatusCause statusCauseObject);
public WatchEventFluent.StatusCauseObjectNested withNewStatusCauseObject();
public WatchEventFluent.StatusCauseObjectNested withNewStatusCauseObjectLike(StatusCause item);
public A withNewStatusCauseObject(String field,String message,String reason);
public A withI18nNameObject(I18nName i18nNameObject);
public WatchEventFluent.I18nNameObjectNested withNewI18nNameObject();
public WatchEventFluent.I18nNameObjectNested withNewI18nNameObjectLike(I18nName item);
public A withNewI18nNameObject(String en,String zhCN);
public A withPipelineRunLimitsObject(PipelineRunLimits pipelineRunLimitsObject);
public WatchEventFluent.PipelineRunLimitsObjectNested withNewPipelineRunLimitsObject();
public WatchEventFluent.PipelineRunLimitsObjectNested withNewPipelineRunLimitsObjectLike(PipelineRunLimits item);
public A withNewPipelineRunLimitsObject(Long failureCount,Long successCount);
public A withNodeConditionObject(NodeCondition nodeConditionObject);
public WatchEventFluent.NodeConditionObjectNested withNewNodeConditionObject();
public WatchEventFluent.NodeConditionObjectNested withNewNodeConditionObjectLike(NodeCondition item);
public A withRollingUpdateDeploymentObject(RollingUpdateDeployment rollingUpdateDeploymentObject);
public WatchEventFluent.RollingUpdateDeploymentObjectNested withNewRollingUpdateDeploymentObject();
public WatchEventFluent.RollingUpdateDeploymentObjectNested withNewRollingUpdateDeploymentObjectLike(RollingUpdateDeployment item);
public A withPipelineStageObject(PipelineStage pipelineStageObject);
public WatchEventFluent.PipelineStageObjectNested withNewPipelineStageObject();
public WatchEventFluent.PipelineStageObjectNested withNewPipelineStageObjectLike(PipelineStage item);
public A withOriginCodeRepositoryObject(OriginCodeRepository originCodeRepositoryObject);
public WatchEventFluent.OriginCodeRepositoryObjectNested withNewOriginCodeRepositoryObject();
public WatchEventFluent.OriginCodeRepositoryObjectNested withNewOriginCodeRepositoryObjectLike(OriginCodeRepository item);
public A withObjectReferenceObject(ObjectReference objectReferenceObject);
public WatchEventFluent.ObjectReferenceObjectNested withNewObjectReferenceObject();
public WatchEventFluent.ObjectReferenceObjectNested withNewObjectReferenceObjectLike(ObjectReference item);
public A withPipelineTemplateSpecObject(PipelineTemplateSpec pipelineTemplateSpecObject);
public WatchEventFluent.PipelineTemplateSpecObjectNested withNewPipelineTemplateSpecObject();
public WatchEventFluent.PipelineTemplateSpecObjectNested withNewPipelineTemplateSpecObjectLike(PipelineTemplateSpec item);
public A withPipelineStrategyJenkinsObject(PipelineStrategyJenkins pipelineStrategyJenkinsObject);
public WatchEventFluent.PipelineStrategyJenkinsObjectNested withNewPipelineStrategyJenkinsObject();
public WatchEventFluent.PipelineStrategyJenkinsObjectNested withNewPipelineStrategyJenkinsObjectLike(PipelineStrategyJenkins item);
public A withPersistentVolumeObject(PersistentVolume persistentVolumeObject);
public WatchEventFluent.PersistentVolumeObjectNested withNewPersistentVolumeObject();
public WatchEventFluent.PersistentVolumeObjectNested withNewPersistentVolumeObjectLike(PersistentVolume item);
public A withCodeRepositoryObject(CodeRepository codeRepositoryObject);
public WatchEventFluent.CodeRepositoryObjectNested withNewCodeRepositoryObject();
public WatchEventFluent.CodeRepositoryObjectNested withNewCodeRepositoryObjectLike(CodeRepository item);
public String getType();
public A withType(String type);
public Boolean hasType();
public interface RepositoryCommitObjectNested extends io.alauda.kubernetes.api.builder.Nested,RepositoryCommitFluent>{
public N and(); public N endRepositoryCommitObject();
}
public interface AffinityObjectNested extends io.alauda.kubernetes.api.builder.Nested,AffinityFluent>{
public N and(); public N endAffinityObject();
}
public interface NamedClusterObjectNested extends io.alauda.kubernetes.api.builder.Nested,NamedClusterFluent>{
public N and(); public N endNamedClusterObject();
}
public interface AWSElasticBlockStoreVolumeSourceObjectNested extends io.alauda.kubernetes.api.builder.Nested,AWSElasticBlockStoreVolumeSourceFluent>{
public N and(); public N endAWSElasticBlockStoreVolumeSourceObject();
}
public interface ContextObjectNested extends io.alauda.kubernetes.api.builder.Nested,ContextFluent>{
public N and(); public N endContextObject();
}
public interface ServicePortObjectNested extends io.alauda.kubernetes.api.builder.Nested,ServicePortFluent>{
public N and(); public N endServicePortObject();
}
public interface BindingObjectNested extends io.alauda.kubernetes.api.builder.Nested,BindingFluent>{
public N and(); public N endBindingObject();
}
public interface AuthInfoObjectNested extends io.alauda.kubernetes.api.builder.Nested,AuthInfoFluent>{
public N and(); public N endAuthInfoObject();
}
public interface IngressObjectNested extends io.alauda.kubernetes.api.builder.Nested,IngressFluent>{
public N and(); public N endIngressObject();
}
public interface ClusterPipelineTaskTemplateListObjectNested extends io.alauda.kubernetes.api.builder.Nested,ClusterPipelineTaskTemplateListFluent>{
public N and(); public N endClusterPipelineTaskTemplateListObject();
}
public interface RollingUpdateStatefulSetStrategyObjectNested extends io.alauda.kubernetes.api.builder.Nested,RollingUpdateStatefulSetStrategyFluent>{
public N and(); public N endRollingUpdateStatefulSetStrategyObject();
}
public interface LocalSubjectAccessReviewObjectNested extends io.alauda.kubernetes.api.builder.Nested,LocalSubjectAccessReviewFluent>{
public N and(); public N endLocalSubjectAccessReviewObject();
}
public interface StatefulSetObjectNested extends io.alauda.kubernetes.api.builder.Nested,StatefulSetFluent>{
public N and(); public N endStatefulSetObject();
}
public interface PipelineTaskArgumentSchemaObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTaskArgumentSchemaFluent>{
public N and(); public N endPipelineTaskArgumentSchemaObject();
}
public interface ContainerObjectNested extends io.alauda.kubernetes.api.builder.Nested,ContainerFluent>{
public N and(); public N endContainerObject();
}
public interface ResourceQuotaSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,ResourceQuotaSpecFluent>{
public N and(); public N endResourceQuotaSpecObject();
}
public interface PipelineTemplateTaskInstanceObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTemplateTaskInstanceFluent>{
public N and(); public N endPipelineTemplateTaskInstanceObject();
}
public interface PipelineTemplateListObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTemplateListFluent>{
public N and(); public N endPipelineTemplateListObject();
}
public interface PipelineTaskOptionObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTaskOptionFluent>{
public N and(); public N endPipelineTaskOptionObject();
}
public interface JobSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,JobSpecFluent>{
public N and(); public N endJobSpecObject();
}
public interface SecretListObjectNested extends io.alauda.kubernetes.api.builder.Nested,SecretListFluent>{
public N and(); public N endSecretListObject();
}
public interface JenkinsListObjectNested extends io.alauda.kubernetes.api.builder.Nested,JenkinsListFluent>{
public N and(); public N endJenkinsListObject();
}
public interface LabelSelectorObjectNested extends io.alauda.kubernetes.api.builder.Nested,LabelSelectorFluent>{
public N and(); public N endLabelSelectorObject();
}
public interface CronJobSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,CronJobSpecFluent>{
public N and(); public N endCronJobSpecObject();
}
public interface DeleteOptionsObjectNested extends io.alauda.kubernetes.api.builder.Nested,DeleteOptionsFluent>{
public N and(); public N endDeleteOptionsObject();
}
public interface PipelineTriggerObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTriggerFluent>{
public N and(); public N endPipelineTriggerObject();
}
public interface DeploymentRollbackObjectNested extends io.alauda.kubernetes.api.builder.Nested,DeploymentRollbackFluent>{
public N and(); public N endDeploymentRollbackObject();
}
public interface SecretVolumeSourceObjectNested extends io.alauda.kubernetes.api.builder.Nested,SecretVolumeSourceFluent>{
public N and(); public N endSecretVolumeSourceObject();
}
public interface DownwardAPIProjectionObjectNested extends io.alauda.kubernetes.api.builder.Nested,DownwardAPIProjectionFluent>{
public N and(); public N endDownwardAPIProjectionObject();
}
public interface LoadBalancerIngressObjectNested extends io.alauda.kubernetes.api.builder.Nested,LoadBalancerIngressFluent>{
public N and(); public N endLoadBalancerIngressObject();
}
public interface CodeRepoBindingAccountObjectNested extends io.alauda.kubernetes.api.builder.Nested,CodeRepoBindingAccountFluent>{
public N and(); public N endCodeRepoBindingAccountObject();
}
public interface HorizontalPodAutoscalerSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,HorizontalPodAutoscalerSpecFluent>{
public N and(); public N endHorizontalPodAutoscalerSpecObject();
}
public interface ProjectNamespaceStatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,ProjectNamespaceStatusFluent>{
public N and(); public N endProjectNamespaceStatusObject();
}
public interface KubernetesRunAsUserStrategyOptionsObjectNested extends io.alauda.kubernetes.api.builder.Nested,KubernetesRunAsUserStrategyOptionsFluent>{
public N and(); public N endKubernetesRunAsUserStrategyOptionsObject();
}
public interface StatusDetailsObjectNested extends io.alauda.kubernetes.api.builder.Nested,StatusDetailsFluent>{
public N and(); public N endStatusDetailsObject();
}
public interface PipelineTaskApproveObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTaskApproveFluent>{
public N and(); public N endPipelineTaskApproveObject();
}
public interface PodSecurityPolicyObjectNested extends io.alauda.kubernetes.api.builder.Nested,PodSecurityPolicyFluent>{
public N and(); public N endPodSecurityPolicyObject();
}
public interface WeightedPodAffinityTermObjectNested extends io.alauda.kubernetes.api.builder.Nested,WeightedPodAffinityTermFluent>{
public N and(); public N endWeightedPodAffinityTermObject();
}
public interface PipelineObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineFluent>{
public N and(); public N endPipelineObject();
}
public interface NodeListObjectNested extends io.alauda.kubernetes.api.builder.Nested,NodeListFluent>{
public N and(); public N endNodeListObject();
}
public interface CinderVolumeSourceObjectNested extends io.alauda.kubernetes.api.builder.Nested,CinderVolumeSourceFluent>{
public N and(); public N endCinderVolumeSourceObject();
}
public interface CustomResourceDefinitionStatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,CustomResourceDefinitionStatusFluent>{
public N and(); public N endCustomResourceDefinitionStatusObject();
}
public interface NetworkPolicySpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,NetworkPolicySpecFluent>{
public N and(); public N endNetworkPolicySpecObject();
}
public interface LocalVolumeSourceObjectNested extends io.alauda.kubernetes.api.builder.Nested,LocalVolumeSourceFluent>{
public N and(); public N endLocalVolumeSourceObject();
}
public interface ResourceQuotaObjectNested extends io.alauda.kubernetes.api.builder.Nested,ResourceQuotaFluent>{
public N and(); public N endResourceQuotaObject();
}
public interface PodListObjectNested extends io.alauda.kubernetes.api.builder.Nested,PodListFluent>{
public N and(); public N endPodListObject();
}
public interface UserInfoObjectNested extends io.alauda.kubernetes.api.builder.Nested,UserInfoFluent>{
public N and(); public N endUserInfoObject();
}
public interface PipelineSourceSvnObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineSourceSvnFluent>{
public N and(); public N endPipelineSourceSvnObject();
}
public interface CustomResourceDefinitionSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,CustomResourceDefinitionSpecFluent>{
public N and(); public N endCustomResourceDefinitionSpecObject();
}
public interface CodeRepositoryStatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,CodeRepositoryStatusFluent>{
public N and(); public N endCodeRepositoryStatusObject();
}
public interface AzureFileVolumeSourceObjectNested extends io.alauda.kubernetes.api.builder.Nested,AzureFileVolumeSourceFluent>{
public N and(); public N endAzureFileVolumeSourceObject();
}
public interface CodeRepoServiceSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,CodeRepoServiceSpecFluent>{
public N and(); public N endCodeRepoServiceSpecObject();
}
public interface ServiceAccountObjectNested extends io.alauda.kubernetes.api.builder.Nested,ServiceAccountFluent>{
public N and(); public N endServiceAccountObject();
}
public interface CodeRepoBindingSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,CodeRepoBindingSpecFluent>{
public N and(); public N endCodeRepoBindingSpecObject();
}
public interface StorageOSPersistentVolumeSourceObjectNested extends io.alauda.kubernetes.api.builder.Nested,StorageOSPersistentVolumeSourceFluent>{
public N and(); public N endStorageOSPersistentVolumeSourceObject();
}
public interface LimitRangeSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,LimitRangeSpecFluent>{
public N and(); public N endLimitRangeSpecObject();
}
public interface PipelineStageInstanceObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineStageInstanceFluent>{
public N and(); public N endPipelineStageInstanceObject();
}
public interface ProjectListObjectNested extends io.alauda.kubernetes.api.builder.Nested,ProjectListFluent>{
public N and(); public N endProjectListObject();
}
public interface ConfigMapObjectNested extends io.alauda.kubernetes.api.builder.Nested,ConfigMapFluent>{
public N and(); public N endConfigMapObject();
}
public interface PipelineCauseObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineCauseFluent>{
public N and(); public N endPipelineCauseObject();
}
public interface VolumeObjectNested extends io.alauda.kubernetes.api.builder.Nested,VolumeFluent>{
public N and(); public N endVolumeObject();
}
public interface FSGroupStrategyOptionsObjectNested extends io.alauda.kubernetes.api.builder.Nested,FSGroupStrategyOptionsFluent>{
public N and(); public N endFSGroupStrategyOptionsObject();
}
public interface PipelineStatusJenkinsObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineStatusJenkinsFluent>{
public N and(); public N endPipelineStatusJenkinsObject();
}
public interface JenkinsBindingObjectNested extends io.alauda.kubernetes.api.builder.Nested,JenkinsBindingFluent>{
public N and(); public N endJenkinsBindingObject();
}
public interface PipelineTemplateObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTemplateFluent>{
public N and(); public N endPipelineTemplateObject();
}
public interface NodeAffinityObjectNested extends io.alauda.kubernetes.api.builder.Nested,NodeAffinityFluent>{
public N and(); public N endNodeAffinityObject();
}
public interface PipelineConfigStatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineConfigStatusFluent>{
public N and(); public N endPipelineConfigStatusObject();
}
public interface ConfigMapListObjectNested extends io.alauda.kubernetes.api.builder.Nested,ConfigMapListFluent>{
public N and(); public N endConfigMapListObject();
}
public interface PipelineTriggeScheduleObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTriggeScheduleFluent>{
public N and(); public N endPipelineTriggeScheduleObject();
}
public interface PipelineTaskTemplateListObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineTaskTemplateListFluent>{
public N and(); public N endPipelineTaskTemplateListObject();
}
public interface DaemonSetStatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,DaemonSetStatusFluent>{
public N and(); public N endDaemonSetStatusObject();
}
public interface BaseKubernetesListObjectNested extends io.alauda.kubernetes.api.builder.Nested,BaseKubernetesListFluent>{
public N and(); public N endBaseKubernetesListObject();
}
public interface InitializerObjectNested extends io.alauda.kubernetes.api.builder.Nested,InitializerFluent>{
public N and(); public N endInitializerObject();
}
public interface StatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,StatusFluent>{
public N and(); public N endStatusObject();
}
public interface CronJobObjectNested extends io.alauda.kubernetes.api.builder.Nested,CronJobFluent>{
public N and(); public N endCronJobObject();
}
public interface ListMetaObjectNested extends io.alauda.kubernetes.api.builder.Nested,ListMetaFluent>{
public N and(); public N endListMetaObject();
}
public interface ComponentStatusListObjectNested extends io.alauda.kubernetes.api.builder.Nested,ComponentStatusListFluent>{
public N and(); public N endComponentStatusListObject();
}
public interface JenkinsBindingListObjectNested extends io.alauda.kubernetes.api.builder.Nested,JenkinsBindingListFluent>{
public N and(); public N endJenkinsBindingListObject();
}
public interface BindingConditionObjectNested extends io.alauda.kubernetes.api.builder.Nested,BindingConditionFluent>{
public N and(); public N endBindingConditionObject();
}
public interface NodeStatusObjectNested extends io.alauda.kubernetes.api.builder.Nested,NodeStatusFluent>{
public N and(); public N endNodeStatusObject();
}
public interface GlobalParameterObjectNested extends io.alauda.kubernetes.api.builder.Nested,GlobalParameterFluent>{
public N and(); public N endGlobalParameterObject();
}
public interface TokenReviewSpecObjectNested extends io.alauda.kubernetes.api.builder.Nested,TokenReviewSpecFluent>{
public N and(); public N endTokenReviewSpecObject();
}
public interface PipelineEnvironmentObjectNested extends io.alauda.kubernetes.api.builder.Nested,PipelineEnvironmentFluent>{
public N and(); public N endPipelineEnvironmentObject();
}
public interface EventListObjectNested