• Home
• io.fabric8
• kubernetes-model-core
• 4.10.0
• source code
• WatchEventFluent.java

×

Project download

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

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

io.fabric8.kubernetes.api.model.WatchEventFluent Maven / Gradle / Ivy

package io.fabric8.kubernetes.api.model;

import java.lang.String;
import java.lang.StringBuilder;
import io.fabric8.kubernetes.api.model.version.Info;
import io.fabric8.kubernetes.api.model.version.InfoBuilder;
import java.lang.StringBuffer;
import java.lang.Long;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.fabric8.kubernetes.api.model.version.InfoFluent;
import java.lang.Boolean;
import java.lang.Object;
import io.fabric8.kubernetes.api.builder.Fluent;
import java.lang.Deprecated;
import java.util.Map;
import java.lang.Integer;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.fabric8.kubernetes.api.builder.Nested;

public interface WatchEventFluent> extends Fluent{


    
/**
 * This method has been deprecated, please use method buildObject instead.
 * @return The buildable object.
 */
@Deprecated public KubernetesResource getObject();
    public KubernetesResource buildObject();
    public A withObject(KubernetesResource object);
    public Boolean hasObject();
    public A withPatchObject(Patch patchObject);
    public WatchEventFluent.PatchObjectNested withNewPatchObject();
    public WatchEventFluent.PatchObjectNested withNewPatchObjectLike(Patch item);
    public A withLimitRangeObject(LimitRange limitRangeObject);
    public WatchEventFluent.LimitRangeObjectNested withNewLimitRangeObject();
    public WatchEventFluent.LimitRangeObjectNested withNewLimitRangeObjectLike(LimitRange item);
    public A withAPIGroupListObject(APIGroupList aPIGroupListObject);
    public WatchEventFluent.APIGroupListObjectNested withNewAPIGroupListObject();
    public WatchEventFluent.APIGroupListObjectNested withNewAPIGroupListObjectLike(APIGroupList item);
    public A withPodTemplateSpecObject(PodTemplateSpec podTemplateSpecObject);
    public WatchEventFluent.PodTemplateSpecObjectNested withNewPodTemplateSpecObject();
    public WatchEventFluent.PodTemplateSpecObjectNested withNewPodTemplateSpecObjectLike(PodTemplateSpec item);
    public A withCSIPersistentVolumeSourceObject(CSIPersistentVolumeSource cSIPersistentVolumeSourceObject);
    public WatchEventFluent.CSIPersistentVolumeSourceObjectNested withNewCSIPersistentVolumeSourceObject();
    public WatchEventFluent.CSIPersistentVolumeSourceObjectNested withNewCSIPersistentVolumeSourceObjectLike(CSIPersistentVolumeSource item);
    public A withAuthInfoObject(AuthInfo authInfoObject);
    public WatchEventFluent.AuthInfoObjectNested withNewAuthInfoObject();
    public WatchEventFluent.AuthInfoObjectNested withNewAuthInfoObjectLike(AuthInfo item);
    public A withResourceRequirementsObject(ResourceRequirements resourceRequirementsObject);
    public WatchEventFluent.ResourceRequirementsObjectNested withNewResourceRequirementsObject();
    public WatchEventFluent.ResourceRequirementsObjectNested withNewResourceRequirementsObjectLike(ResourceRequirements 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 withHostPathVolumeSourceObject(HostPathVolumeSource hostPathVolumeSourceObject);
    public WatchEventFluent.HostPathVolumeSourceObjectNested withNewHostPathVolumeSourceObject();
    public WatchEventFluent.HostPathVolumeSourceObjectNested withNewHostPathVolumeSourceObjectLike(HostPathVolumeSource item);
    public A withNewHostPathVolumeSourceObject(String path,String type);
    public A withNamedContextObject(NamedContext namedContextObject);
    public WatchEventFluent.NamedContextObjectNested withNewNamedContextObject();
    public WatchEventFluent.NamedContextObjectNested withNewNamedContextObjectLike(NamedContext item);
    public A withPersistentVolumeClaimListObject(PersistentVolumeClaimList persistentVolumeClaimListObject);
    public WatchEventFluent.PersistentVolumeClaimListObjectNested withNewPersistentVolumeClaimListObject();
    public WatchEventFluent.PersistentVolumeClaimListObjectNested withNewPersistentVolumeClaimListObjectLike(PersistentVolumeClaimList item);
    public A withConfigObject(Config configObject);
    public WatchEventFluent.ConfigObjectNested withNewConfigObject();
    public WatchEventFluent.ConfigObjectNested withNewConfigObjectLike(Config item);
    public A withAffinityObject(Affinity affinityObject);
    public WatchEventFluent.AffinityObjectNested withNewAffinityObject();
    public WatchEventFluent.AffinityObjectNested withNewAffinityObjectLike(Affinity item);
    public A withReplicationControllerStatusObject(ReplicationControllerStatus replicationControllerStatusObject);
    public WatchEventFluent.ReplicationControllerStatusObjectNested withNewReplicationControllerStatusObject();
    public WatchEventFluent.ReplicationControllerStatusObjectNested withNewReplicationControllerStatusObjectLike(ReplicationControllerStatus item);
    public A withMicroTimeObject(MicroTime microTimeObject);
    public WatchEventFluent.MicroTimeObjectNested withNewMicroTimeObject();
    public WatchEventFluent.MicroTimeObjectNested withNewMicroTimeObjectLike(MicroTime item);
    public A withNewMicroTimeObject(String time);
    public A withLifecycleObject(Lifecycle lifecycleObject);
    public WatchEventFluent.LifecycleObjectNested withNewLifecycleObject();
    public WatchEventFluent.LifecycleObjectNested withNewLifecycleObjectLike(Lifecycle 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 withEventSourceObject(EventSource eventSourceObject);
    public WatchEventFluent.EventSourceObjectNested withNewEventSourceObject();
    public WatchEventFluent.EventSourceObjectNested withNewEventSourceObjectLike(EventSource item);
    public A withNewEventSourceObject(String component,String host);
    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 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 withEnvVarObject(EnvVar envVarObject);
    public WatchEventFluent.EnvVarObjectNested withNewEnvVarObject();
    public WatchEventFluent.EnvVarObjectNested withNewEnvVarObjectLike(EnvVar item);
    public A withReplicationControllerSpecObject(ReplicationControllerSpec replicationControllerSpecObject);
    public WatchEventFluent.ReplicationControllerSpecObjectNested withNewReplicationControllerSpecObject();
    public WatchEventFluent.ReplicationControllerSpecObjectNested withNewReplicationControllerSpecObjectLike(ReplicationControllerSpec 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 withAttachedVolumeObject(AttachedVolume attachedVolumeObject);
    public WatchEventFluent.AttachedVolumeObjectNested withNewAttachedVolumeObject();
    public WatchEventFluent.AttachedVolumeObjectNested withNewAttachedVolumeObjectLike(AttachedVolume item);
    public A withNewAttachedVolumeObject(String devicePath,String name);
    public A withLocalObjectReference(LocalObjectReference localObjectReference);
    public WatchEventFluent.LocalObjectReferenceNested withNewLocalObjectReference();
    public WatchEventFluent.LocalObjectReferenceNested withNewLocalObjectReferenceLike(LocalObjectReference item);
    public A withNewLocalObjectReference(String name);
    public A withNamedAuthInfoObject(NamedAuthInfo namedAuthInfoObject);
    public WatchEventFluent.NamedAuthInfoObjectNested withNewNamedAuthInfoObject();
    public WatchEventFluent.NamedAuthInfoObjectNested withNewNamedAuthInfoObjectLike(NamedAuthInfo item);
    public A withEmptyDirVolumeSourceObject(EmptyDirVolumeSource emptyDirVolumeSourceObject);
    public WatchEventFluent.EmptyDirVolumeSourceObjectNested withNewEmptyDirVolumeSourceObject();
    public WatchEventFluent.EmptyDirVolumeSourceObjectNested withNewEmptyDirVolumeSourceObjectLike(EmptyDirVolumeSource item);
    public A withPodSpecObject(PodSpec podSpecObject);
    public WatchEventFluent.PodSpecObjectNested withNewPodSpecObject();
    public WatchEventFluent.PodSpecObjectNested withNewPodSpecObjectLike(PodSpec item);
    public A withServerAddressByClientCIDRObject(ServerAddressByClientCIDR serverAddressByClientCIDRObject);
    public WatchEventFluent.ServerAddressByClientCIDRObjectNested withNewServerAddressByClientCIDRObject();
    public WatchEventFluent.ServerAddressByClientCIDRObjectNested withNewServerAddressByClientCIDRObjectLike(ServerAddressByClientCIDR item);
    public A withNewServerAddressByClientCIDRObject(String clientCIDR,String serverAddress);
    public A withAzureDiskVolumeSourceObject(AzureDiskVolumeSource azureDiskVolumeSourceObject);
    public WatchEventFluent.AzureDiskVolumeSourceObjectNested withNewAzureDiskVolumeSourceObject();
    public WatchEventFluent.AzureDiskVolumeSourceObjectNested withNewAzureDiskVolumeSourceObjectLike(AzureDiskVolumeSource item);
    public A withPreconditionsObject(Preconditions preconditionsObject);
    public WatchEventFluent.PreconditionsObjectNested withNewPreconditionsObject();
    public WatchEventFluent.PreconditionsObjectNested withNewPreconditionsObjectLike(Preconditions item);
    public A withNewPreconditionsObject(String resourceVersion,String uid);
    public A withInfoObject(Info infoObject);
    public WatchEventFluent.InfoObjectNested withNewInfoObject();
    public WatchEventFluent.InfoObjectNested withNewInfoObjectLike(Info item);
    public A withCephFSVolumeSourceObject(CephFSVolumeSource cephFSVolumeSourceObject);
    public WatchEventFluent.CephFSVolumeSourceObjectNested withNewCephFSVolumeSourceObject();
    public WatchEventFluent.CephFSVolumeSourceObjectNested withNewCephFSVolumeSourceObjectLike(CephFSVolumeSource item);
    public A withEphemeralContainerObject(EphemeralContainer ephemeralContainerObject);
    public WatchEventFluent.EphemeralContainerObjectNested withNewEphemeralContainerObject();
    public WatchEventFluent.EphemeralContainerObjectNested withNewEphemeralContainerObjectLike(EphemeralContainer item);
    public A withNodeConditionObject(NodeCondition nodeConditionObject);
    public WatchEventFluent.NodeConditionObjectNested withNewNodeConditionObject();
    public WatchEventFluent.NodeConditionObjectNested withNewNodeConditionObjectLike(NodeCondition item);
    public A withEndpointSubsetObject(EndpointSubset endpointSubsetObject);
    public WatchEventFluent.EndpointSubsetObjectNested withNewEndpointSubsetObject();
    public WatchEventFluent.EndpointSubsetObjectNested withNewEndpointSubsetObjectLike(EndpointSubset item);
    public A withLocalVolumeSourceObject(LocalVolumeSource localVolumeSourceObject);
    public WatchEventFluent.LocalVolumeSourceObjectNested withNewLocalVolumeSourceObject();
    public WatchEventFluent.LocalVolumeSourceObjectNested withNewLocalVolumeSourceObjectLike(LocalVolumeSource item);
    public A withNewLocalVolumeSourceObject(String fsType,String path);
    public A withServiceStatusObject(ServiceStatus serviceStatusObject);
    public WatchEventFluent.ServiceStatusObjectNested withNewServiceStatusObject();
    public WatchEventFluent.ServiceStatusObjectNested withNewServiceStatusObjectLike(ServiceStatus 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 withPatchOptionsObject(PatchOptions patchOptionsObject);
    public WatchEventFluent.PatchOptionsObjectNested withNewPatchOptionsObject();
    public WatchEventFluent.PatchOptionsObjectNested withNewPatchOptionsObjectLike(PatchOptions item);
    public A withConfigMapNodeConfigSourceObject(ConfigMapNodeConfigSource configMapNodeConfigSourceObject);
    public WatchEventFluent.ConfigMapNodeConfigSourceObjectNested withNewConfigMapNodeConfigSourceObject();
    public WatchEventFluent.ConfigMapNodeConfigSourceObjectNested withNewConfigMapNodeConfigSourceObjectLike(ConfigMapNodeConfigSource item);
    public A withNewConfigMapNodeConfigSourceObject(String kubeletConfigKey,String name,String namespace,String resourceVersion,String uid);
    public A withHTTPGetActionObject(HTTPGetAction hTTPGetActionObject);
    public WatchEventFluent.HTTPGetActionObjectNested withNewHTTPGetActionObject();
    public WatchEventFluent.HTTPGetActionObjectNested withNewHTTPGetActionObjectLike(HTTPGetAction item);
    public A withGlusterfsPersistentVolumeSourceObject(GlusterfsPersistentVolumeSource glusterfsPersistentVolumeSourceObject);
    public WatchEventFluent.GlusterfsPersistentVolumeSourceObjectNested withNewGlusterfsPersistentVolumeSourceObject();
    public WatchEventFluent.GlusterfsPersistentVolumeSourceObjectNested withNewGlusterfsPersistentVolumeSourceObjectLike(GlusterfsPersistentVolumeSource item);
    public A withNewGlusterfsPersistentVolumeSourceObject(String endpoints,String endpointsNamespace,String path,Boolean readOnly);
    public A withDownwardAPIVolumeSourceObject(DownwardAPIVolumeSource downwardAPIVolumeSourceObject);
    public WatchEventFluent.DownwardAPIVolumeSourceObjectNested withNewDownwardAPIVolumeSourceObject();
    public WatchEventFluent.DownwardAPIVolumeSourceObjectNested withNewDownwardAPIVolumeSourceObjectLike(DownwardAPIVolumeSource item);
    public A withISCSIPersistentVolumeSourceObject(ISCSIPersistentVolumeSource iSCSIPersistentVolumeSourceObject);
    public WatchEventFluent.ISCSIPersistentVolumeSourceObjectNested withNewISCSIPersistentVolumeSourceObject();
    public WatchEventFluent.ISCSIPersistentVolumeSourceObjectNested withNewISCSIPersistentVolumeSourceObjectLike(ISCSIPersistentVolumeSource item);
    public A withWindowsSecurityContextOptionsObject(WindowsSecurityContextOptions windowsSecurityContextOptionsObject);
    public WatchEventFluent.WindowsSecurityContextOptionsObjectNested withNewWindowsSecurityContextOptionsObject();
    public WatchEventFluent.WindowsSecurityContextOptionsObjectNested withNewWindowsSecurityContextOptionsObjectLike(WindowsSecurityContextOptions item);
    public A withNewWindowsSecurityContextOptionsObject(String gmsaCredentialSpec,String gmsaCredentialSpecName,String runAsUserName);
    public A withEnvFromSourceObject(EnvFromSource envFromSourceObject);
    public WatchEventFluent.EnvFromSourceObjectNested withNewEnvFromSourceObject();
    public WatchEventFluent.EnvFromSourceObjectNested withNewEnvFromSourceObjectLike(EnvFromSource item);
    public A withCreateOptionsObject(CreateOptions createOptionsObject);
    public WatchEventFluent.CreateOptionsObjectNested withNewCreateOptionsObject();
    public WatchEventFluent.CreateOptionsObjectNested withNewCreateOptionsObjectLike(CreateOptions item);
    public A withNamespaceSpecObject(NamespaceSpec namespaceSpecObject);
    public WatchEventFluent.NamespaceSpecObjectNested withNewNamespaceSpecObject();
    public WatchEventFluent.NamespaceSpecObjectNested withNewNamespaceSpecObjectLike(NamespaceSpec item);
    public A withListMetaObject(ListMeta listMetaObject);
    public WatchEventFluent.ListMetaObjectNested withNewListMetaObject();
    public WatchEventFluent.ListMetaObjectNested withNewListMetaObjectLike(ListMeta item);
    public A withNewListMetaObject(String _continue,Long remainingItemCount,String resourceVersion,String selfLink);
    public A withRootPathsObject(RootPaths rootPathsObject);
    public WatchEventFluent.RootPathsObjectNested withNewRootPathsObject();
    public WatchEventFluent.RootPathsObjectNested withNewRootPathsObjectLike(RootPaths item);
    public A withTypeMetaObject(TypeMeta typeMetaObject);
    public WatchEventFluent.TypeMetaObjectNested withNewTypeMetaObject();
    public WatchEventFluent.TypeMetaObjectNested withNewTypeMetaObjectLike(TypeMeta item);
    public A withNewTypeMetaObject(String apiVersion,String kind);
    public A withSecretReferenceObject(SecretReference secretReferenceObject);
    public WatchEventFluent.SecretReferenceObjectNested withNewSecretReferenceObject();
    public WatchEventFluent.SecretReferenceObjectNested withNewSecretReferenceObjectLike(SecretReference item);
    public A withNewSecretReferenceObject(String name,String namespace);
    public A withAPIGroupObject(APIGroup aPIGroupObject);
    public WatchEventFluent.APIGroupObjectNested withNewAPIGroupObject();
    public WatchEventFluent.APIGroupObjectNested withNewAPIGroupObjectLike(APIGroup item);
    public A withFlexVolumeSourceObject(FlexVolumeSource flexVolumeSourceObject);
    public WatchEventFluent.FlexVolumeSourceObjectNested withNewFlexVolumeSourceObject();
    public WatchEventFluent.FlexVolumeSourceObjectNested withNewFlexVolumeSourceObjectLike(FlexVolumeSource item);
    public A withISCSIVolumeSourceObject(ISCSIVolumeSource iSCSIVolumeSourceObject);
    public WatchEventFluent.ISCSIVolumeSourceObjectNested withNewISCSIVolumeSourceObject();
    public WatchEventFluent.ISCSIVolumeSourceObjectNested withNewISCSIVolumeSourceObjectLike(ISCSIVolumeSource 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 withRBDVolumeSourceObject(RBDVolumeSource rBDVolumeSourceObject);
    public WatchEventFluent.RBDVolumeSourceObjectNested withNewRBDVolumeSourceObject();
    public WatchEventFluent.RBDVolumeSourceObjectNested withNewRBDVolumeSourceObjectLike(RBDVolumeSource item);
    public A withResourceQuotaListObject(ResourceQuotaList resourceQuotaListObject);
    public WatchEventFluent.ResourceQuotaListObjectNested withNewResourceQuotaListObject();
    public WatchEventFluent.ResourceQuotaListObjectNested withNewResourceQuotaListObjectLike(ResourceQuotaList item);
    public A withNodeConfigStatusObject(NodeConfigStatus nodeConfigStatusObject);
    public WatchEventFluent.NodeConfigStatusObjectNested withNewNodeConfigStatusObject();
    public WatchEventFluent.NodeConfigStatusObjectNested withNewNodeConfigStatusObjectLike(NodeConfigStatus item);
    public A withQuobyteVolumeSourceObject(QuobyteVolumeSource quobyteVolumeSourceObject);
    public WatchEventFluent.QuobyteVolumeSourceObjectNested withNewQuobyteVolumeSourceObject();
    public WatchEventFluent.QuobyteVolumeSourceObjectNested withNewQuobyteVolumeSourceObjectLike(QuobyteVolumeSource item);
    public A withResourceQuotaStatusObject(ResourceQuotaStatus resourceQuotaStatusObject);
    public WatchEventFluent.ResourceQuotaStatusObjectNested withNewResourceQuotaStatusObject();
    public WatchEventFluent.ResourceQuotaStatusObjectNested withNewResourceQuotaStatusObjectLike(ResourceQuotaStatus item);
    public A withConfigMapProjectionObject(ConfigMapProjection configMapProjectionObject);
    public WatchEventFluent.ConfigMapProjectionObjectNested withNewConfigMapProjectionObject();
    public WatchEventFluent.ConfigMapProjectionObjectNested withNewConfigMapProjectionObjectLike(ConfigMapProjection item);
    public A withScopedResourceSelectorRequirementObject(ScopedResourceSelectorRequirement scopedResourceSelectorRequirementObject);
    public WatchEventFluent.ScopedResourceSelectorRequirementObjectNested withNewScopedResourceSelectorRequirementObject();
    public WatchEventFluent.ScopedResourceSelectorRequirementObjectNested withNewScopedResourceSelectorRequirementObjectLike(ScopedResourceSelectorRequirement item);
    public A withNamespaceObject(Namespace namespaceObject);
    public WatchEventFluent.NamespaceObjectNested withNewNamespaceObject();
    public WatchEventFluent.NamespaceObjectNested withNewNamespaceObjectLike(Namespace item);
    public A withContainerStateTerminatedObject(ContainerStateTerminated containerStateTerminatedObject);
    public WatchEventFluent.ContainerStateTerminatedObjectNested withNewContainerStateTerminatedObject();
    public WatchEventFluent.ContainerStateTerminatedObjectNested withNewContainerStateTerminatedObjectLike(ContainerStateTerminated item);
    public A withGroupVersionKindObject(GroupVersionKind groupVersionKindObject);
    public WatchEventFluent.GroupVersionKindObjectNested withNewGroupVersionKindObject();
    public WatchEventFluent.GroupVersionKindObjectNested withNewGroupVersionKindObjectLike(GroupVersionKind item);
    public A withNewGroupVersionKindObject(String group,String kind,String version);
    public A withLimitRangeSpecObject(LimitRangeSpec limitRangeSpecObject);
    public WatchEventFluent.LimitRangeSpecObjectNested withNewLimitRangeSpecObject();
    public WatchEventFluent.LimitRangeSpecObjectNested withNewLimitRangeSpecObjectLike(LimitRangeSpec item);
    public A withProjectedVolumeSourceObject(ProjectedVolumeSource projectedVolumeSourceObject);
    public WatchEventFluent.ProjectedVolumeSourceObjectNested withNewProjectedVolumeSourceObject();
    public WatchEventFluent.ProjectedVolumeSourceObjectNested withNewProjectedVolumeSourceObjectLike(ProjectedVolumeSource item);
    public A withHandlerObject(Handler handlerObject);
    public WatchEventFluent.HandlerObjectNested withNewHandlerObject();
    public WatchEventFluent.HandlerObjectNested withNewHandlerObjectLike(Handler item);
    public A withPersistentVolumeClaimStatusObject(PersistentVolumeClaimStatus persistentVolumeClaimStatusObject);
    public WatchEventFluent.PersistentVolumeClaimStatusObjectNested withNewPersistentVolumeClaimStatusObject();
    public WatchEventFluent.PersistentVolumeClaimStatusObjectNested withNewPersistentVolumeClaimStatusObjectLike(PersistentVolumeClaimStatus item);
    public A withContainerStateObject(ContainerState containerStateObject);
    public WatchEventFluent.ContainerStateObjectNested withNewContainerStateObject();
    public WatchEventFluent.ContainerStateObjectNested withNewContainerStateObjectLike(ContainerState item);
    public A withServiceSpecObject(ServiceSpec serviceSpecObject);
    public WatchEventFluent.ServiceSpecObjectNested withNewServiceSpecObject();
    public WatchEventFluent.ServiceSpecObjectNested withNewServiceSpecObjectLike(ServiceSpec item);
    public A withServiceAccountTokenProjectionObject(ServiceAccountTokenProjection serviceAccountTokenProjectionObject);
    public WatchEventFluent.ServiceAccountTokenProjectionObjectNested withNewServiceAccountTokenProjectionObject();
    public WatchEventFluent.ServiceAccountTokenProjectionObjectNested withNewServiceAccountTokenProjectionObjectLike(ServiceAccountTokenProjection item);
    public A withNewServiceAccountTokenProjectionObject(String audience,Long expirationSeconds,String path);
    public A withPhotonPersistentDiskVolumeSourceObject(PhotonPersistentDiskVolumeSource photonPersistentDiskVolumeSourceObject);
    public WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested withNewPhotonPersistentDiskVolumeSourceObject();
    public WatchEventFluent.PhotonPersistentDiskVolumeSourceObjectNested withNewPhotonPersistentDiskVolumeSourceObjectLike(PhotonPersistentDiskVolumeSource item);
    public A withNewPhotonPersistentDiskVolumeSourceObject(String fsType,String pdID);
    public A withContainerObject(Container containerObject);
    public WatchEventFluent.ContainerObjectNested withNewContainerObject();
    public WatchEventFluent.ContainerObjectNested withNewContainerObjectLike(Container item);
    public A withNodeSpecObject(NodeSpec nodeSpecObject);
    public WatchEventFluent.NodeSpecObjectNested withNewNodeSpecObject();
    public WatchEventFluent.NodeSpecObjectNested withNewNodeSpecObjectLike(NodeSpec item);
    public A withTypedLocalObjectReference(TypedLocalObjectReference typedLocalObjectReference);
    public WatchEventFluent.TypedLocalObjectReferenceNested withNewTypedLocalObjectReference();
    public WatchEventFluent.TypedLocalObjectReferenceNested withNewTypedLocalObjectReferenceLike(TypedLocalObjectReference item);
    public A withNewTypedLocalObjectReference(String apiGroup,String kind,String name);
    public A withFieldsV1Object(FieldsV1 fieldsV1Object);
    public WatchEventFluent.FieldsV1ObjectNested withNewFieldsV1Object();
    public WatchEventFluent.FieldsV1ObjectNested withNewFieldsV1ObjectLike(FieldsV1 item);
    public A withSecretListObject(SecretList secretListObject);
    public WatchEventFluent.SecretListObjectNested withNewSecretListObject();
    public WatchEventFluent.SecretListObjectNested withNewSecretListObjectLike(SecretList item);
    public A withNodeAddressObject(NodeAddress nodeAddressObject);
    public WatchEventFluent.NodeAddressObjectNested withNewNodeAddressObject();
    public WatchEventFluent.NodeAddressObjectNested withNewNodeAddressObjectLike(NodeAddress item);
    public A withNewNodeAddressObject(String address,String type);
    public A withPodAffinityObject(PodAffinity podAffinityObject);
    public WatchEventFluent.PodAffinityObjectNested withNewPodAffinityObject();
    public WatchEventFluent.PodAffinityObjectNested withNewPodAffinityObjectLike(PodAffinity item);
    public A withExecEnvVarObject(ExecEnvVar execEnvVarObject);
    public WatchEventFluent.ExecEnvVarObjectNested withNewExecEnvVarObject();
    public WatchEventFluent.ExecEnvVarObjectNested withNewExecEnvVarObjectLike(ExecEnvVar item);
    public A withNewExecEnvVarObject(String name,String value);
    public A withServiceObject(Service serviceObject);
    public WatchEventFluent.ServiceObjectNested withNewServiceObject();
    public WatchEventFluent.ServiceObjectNested withNewServiceObjectLike(Service item);
    public A withPodConditionObject(PodCondition podConditionObject);
    public WatchEventFluent.PodConditionObjectNested withNewPodConditionObject();
    public WatchEventFluent.PodConditionObjectNested withNewPodConditionObjectLike(PodCondition item);
    public A withTopologySpreadConstraintObject(TopologySpreadConstraint topologySpreadConstraintObject);
    public WatchEventFluent.TopologySpreadConstraintObjectNested withNewTopologySpreadConstraintObject();
    public WatchEventFluent.TopologySpreadConstraintObjectNested withNewTopologySpreadConstraintObjectLike(TopologySpreadConstraint item);
    public A withExecActionObject(ExecAction execActionObject);
    public WatchEventFluent.ExecActionObjectNested withNewExecActionObject();
    public WatchEventFluent.ExecActionObjectNested withNewExecActionObjectLike(ExecAction item);
    public A withContainerImageObject(ContainerImage containerImageObject);
    public WatchEventFluent.ContainerImageObjectNested withNewContainerImageObject();
    public WatchEventFluent.ContainerImageObjectNested withNewContainerImageObjectLike(ContainerImage item);
    public A withReplicationControllerObject(ReplicationController replicationControllerObject);
    public WatchEventFluent.ReplicationControllerObjectNested withNewReplicationControllerObject();
    public WatchEventFluent.ReplicationControllerObjectNested withNewReplicationControllerObjectLike(ReplicationController item);
    public A withNodeStatusObject(NodeStatus nodeStatusObject);
    public WatchEventFluent.NodeStatusObjectNested withNewNodeStatusObject();
    public WatchEventFluent.NodeStatusObjectNested withNewNodeStatusObjectLike(NodeStatus item);
    public A withConfigMapListObject(ConfigMapList configMapListObject);
    public WatchEventFluent.ConfigMapListObjectNested withNewConfigMapListObject();
    public WatchEventFluent.ConfigMapListObjectNested withNewConfigMapListObjectLike(ConfigMapList item);
    public A withNodeSelectorObject(NodeSelector nodeSelectorObject);
    public WatchEventFluent.NodeSelectorObjectNested withNewNodeSelectorObject();
    public WatchEventFluent.NodeSelectorObjectNested withNewNodeSelectorObjectLike(NodeSelector 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 withCephFSPersistentVolumeSourceObject(CephFSPersistentVolumeSource cephFSPersistentVolumeSourceObject);
    public WatchEventFluent.CephFSPersistentVolumeSourceObjectNested withNewCephFSPersistentVolumeSourceObject();
    public WatchEventFluent.CephFSPersistentVolumeSourceObjectNested withNewCephFSPersistentVolumeSourceObjectLike(CephFSPersistentVolumeSource item);
    public A withPersistentVolumeClaimConditionObject(PersistentVolumeClaimCondition persistentVolumeClaimConditionObject);
    public WatchEventFluent.PersistentVolumeClaimConditionObjectNested withNewPersistentVolumeClaimConditionObject();
    public WatchEventFluent.PersistentVolumeClaimConditionObjectNested withNewPersistentVolumeClaimConditionObjectLike(PersistentVolumeClaimCondition item);
    public A withPreferredSchedulingTermObject(PreferredSchedulingTerm preferredSchedulingTermObject);
    public WatchEventFluent.PreferredSchedulingTermObjectNested withNewPreferredSchedulingTermObject();
    public WatchEventFluent.PreferredSchedulingTermObjectNested withNewPreferredSchedulingTermObjectLike(PreferredSchedulingTerm item);
    public A withPersistentVolumeListObject(PersistentVolumeList persistentVolumeListObject);
    public WatchEventFluent.PersistentVolumeListObjectNested withNewPersistentVolumeListObject();
    public WatchEventFluent.PersistentVolumeListObjectNested withNewPersistentVolumeListObjectLike(PersistentVolumeList item);
    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 withPodDNSConfigOptionObject(PodDNSConfigOption podDNSConfigOptionObject);
    public WatchEventFluent.PodDNSConfigOptionObjectNested withNewPodDNSConfigOptionObject();
    public WatchEventFluent.PodDNSConfigOptionObjectNested withNewPodDNSConfigOptionObjectLike(PodDNSConfigOption item);
    public A withNewPodDNSConfigOptionObject(String name,String value);
    public A withPodReadinessGateObject(PodReadinessGate podReadinessGateObject);
    public WatchEventFluent.PodReadinessGateObjectNested withNewPodReadinessGateObject();
    public WatchEventFluent.PodReadinessGateObjectNested withNewPodReadinessGateObjectLike(PodReadinessGate item);
    public A withNewPodReadinessGateObject(String conditionType);
    public A withContainerStateWaitingObject(ContainerStateWaiting containerStateWaitingObject);
    public WatchEventFluent.ContainerStateWaitingObjectNested withNewContainerStateWaitingObject();
    public WatchEventFluent.ContainerStateWaitingObjectNested withNewContainerStateWaitingObjectLike(ContainerStateWaiting item);
    public A withNewContainerStateWaitingObject(String message,String reason);
    public A withVolumeMountObject(VolumeMount volumeMountObject);
    public WatchEventFluent.VolumeMountObjectNested withNewVolumeMountObject();
    public WatchEventFluent.VolumeMountObjectNested withNewVolumeMountObjectLike(VolumeMount item);
    public A withNamespaceConditionObject(NamespaceCondition namespaceConditionObject);
    public WatchEventFluent.NamespaceConditionObjectNested withNewNamespaceConditionObject();
    public WatchEventFluent.NamespaceConditionObjectNested withNewNamespaceConditionObjectLike(NamespaceCondition item);
    public A withNewNamespaceConditionObject(String lastTransitionTime,String message,String reason,String status,String type);
    public A withLabelSelectorObject(LabelSelector labelSelectorObject);
    public WatchEventFluent.LabelSelectorObjectNested withNewLabelSelectorObject();
    public WatchEventFluent.LabelSelectorObjectNested withNewLabelSelectorObjectLike(LabelSelector item);
    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 withNamedClusterObject(NamedCluster namedClusterObject);
    public WatchEventFluent.NamedClusterObjectNested withNewNamedClusterObject();
    public WatchEventFluent.NamedClusterObjectNested withNewNamedClusterObjectLike(NamedCluster item);
    public A withStatusDetailsObject(StatusDetails statusDetailsObject);
    public WatchEventFluent.StatusDetailsObjectNested withNewStatusDetailsObject();
    public WatchEventFluent.StatusDetailsObjectNested withNewStatusDetailsObjectLike(StatusDetails item);
    public A withDownwardAPIVolumeFileObject(DownwardAPIVolumeFile downwardAPIVolumeFileObject);
    public WatchEventFluent.DownwardAPIVolumeFileObjectNested withNewDownwardAPIVolumeFileObject();
    public WatchEventFluent.DownwardAPIVolumeFileObjectNested withNewDownwardAPIVolumeFileObjectLike(DownwardAPIVolumeFile item);
    public A withSysctlObject(Sysctl sysctlObject);
    public WatchEventFluent.SysctlObjectNested withNewSysctlObject();
    public WatchEventFluent.SysctlObjectNested withNewSysctlObjectLike(Sysctl item);
    public A withNewSysctlObject(String name,String value);
    public A withDeleteOptionsObject(DeleteOptions deleteOptionsObject);
    public WatchEventFluent.DeleteOptionsObjectNested withNewDeleteOptionsObject();
    public WatchEventFluent.DeleteOptionsObjectNested withNewDeleteOptionsObjectLike(DeleteOptions item);
    public A withStatusObject(Status statusObject);
    public WatchEventFluent.StatusObjectNested withNewStatusObject();
    public WatchEventFluent.StatusObjectNested withNewStatusObjectLike(Status item);
    public A withContainerStatusObject(ContainerStatus containerStatusObject);
    public WatchEventFluent.ContainerStatusObjectNested withNewContainerStatusObject();
    public WatchEventFluent.ContainerStatusObjectNested withNewContainerStatusObjectLike(ContainerStatus item);
    public A withPodTemplateObject(PodTemplate podTemplateObject);
    public WatchEventFluent.PodTemplateObjectNested withNewPodTemplateObject();
    public WatchEventFluent.PodTemplateObjectNested withNewPodTemplateObjectLike(PodTemplate 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 withNodeSelectorRequirementObject(NodeSelectorRequirement nodeSelectorRequirementObject);
    public WatchEventFluent.NodeSelectorRequirementObjectNested withNewNodeSelectorRequirementObject();
    public WatchEventFluent.NodeSelectorRequirementObjectNested withNewNodeSelectorRequirementObjectLike(NodeSelectorRequirement item);
    public A withTCPSocketActionObject(TCPSocketAction tCPSocketActionObject);
    public WatchEventFluent.TCPSocketActionObjectNested withNewTCPSocketActionObject();
    public WatchEventFluent.TCPSocketActionObjectNested withNewTCPSocketActionObjectLike(TCPSocketAction item);
    public A withPreferencesObject(Preferences preferencesObject);
    public WatchEventFluent.PreferencesObjectNested withNewPreferencesObject();
    public WatchEventFluent.PreferencesObjectNested withNewPreferencesObjectLike(Preferences 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 withPodTemplateListObject(PodTemplateList podTemplateListObject);
    public WatchEventFluent.PodTemplateListObjectNested withNewPodTemplateListObject();
    public WatchEventFluent.PodTemplateListObjectNested withNewPodTemplateListObjectLike(PodTemplateList item);
    public A withPersistentVolumeObject(PersistentVolume persistentVolumeObject);
    public WatchEventFluent.PersistentVolumeObjectNested withNewPersistentVolumeObject();
    public WatchEventFluent.PersistentVolumeObjectNested withNewPersistentVolumeObjectLike(PersistentVolume item);
    public A withEndpointAddressObject(EndpointAddress endpointAddressObject);
    public WatchEventFluent.EndpointAddressObjectNested withNewEndpointAddressObject();
    public WatchEventFluent.EndpointAddressObjectNested withNewEndpointAddressObjectLike(EndpointAddress item);
    public A withCinderVolumeSourceObject(CinderVolumeSource cinderVolumeSourceObject);
    public WatchEventFluent.CinderVolumeSourceObjectNested withNewCinderVolumeSourceObject();
    public WatchEventFluent.CinderVolumeSourceObjectNested withNewCinderVolumeSourceObjectLike(CinderVolumeSource item);
    public A withNodeConfigSourceObject(NodeConfigSource nodeConfigSourceObject);
    public WatchEventFluent.NodeConfigSourceObjectNested withNewNodeConfigSourceObject();
    public WatchEventFluent.NodeConfigSourceObjectNested withNewNodeConfigSourceObjectLike(NodeConfigSource 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 withObjectMetaObject(ObjectMeta objectMetaObject);
    public WatchEventFluent.ObjectMetaObjectNested withNewObjectMetaObject();
    public WatchEventFluent.ObjectMetaObjectNested withNewObjectMetaObjectLike(ObjectMeta item);
    public A withPersistentVolumeClaimObject(PersistentVolumeClaim persistentVolumeClaimObject);
    public WatchEventFluent.PersistentVolumeClaimObjectNested withNewPersistentVolumeClaimObject();
    public WatchEventFluent.PersistentVolumeClaimObjectNested withNewPersistentVolumeClaimObjectLike(PersistentVolumeClaim item);
    public A withLabelSelectorRequirementObject(LabelSelectorRequirement labelSelectorRequirementObject);
    public WatchEventFluent.LabelSelectorRequirementObjectNested withNewLabelSelectorRequirementObject();
    public WatchEventFluent.LabelSelectorRequirementObjectNested withNewLabelSelectorRequirementObjectLike(LabelSelectorRequirement 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 withEndpointsListObject(EndpointsList endpointsListObject);
    public WatchEventFluent.EndpointsListObjectNested withNewEndpointsListObject();
    public WatchEventFluent.EndpointsListObjectNested withNewEndpointsListObjectLike(EndpointsList item);
    public A withGroupVersionResourceObject(GroupVersionResource groupVersionResourceObject);
    public WatchEventFluent.GroupVersionResourceObjectNested withNewGroupVersionResourceObject();
    public WatchEventFluent.GroupVersionResourceObjectNested withNewGroupVersionResourceObjectLike(GroupVersionResource item);
    public A withNewGroupVersionResourceObject(String group,String resource,String version);
    public A withCinderPersistentVolumeSourceObject(CinderPersistentVolumeSource cinderPersistentVolumeSourceObject);
    public WatchEventFluent.CinderPersistentVolumeSourceObjectNested withNewCinderPersistentVolumeSourceObject();
    public WatchEventFluent.CinderPersistentVolumeSourceObjectNested withNewCinderPersistentVolumeSourceObjectLike(CinderPersistentVolumeSource item);
    public A withTopologySelectorTermObject(TopologySelectorTerm topologySelectorTermObject);
    public WatchEventFluent.TopologySelectorTermObjectNested withNewTopologySelectorTermObject();
    public WatchEventFluent.TopologySelectorTermObjectNested withNewTopologySelectorTermObjectLike(TopologySelectorTerm item);
    public A withOwnerReferenceObject(OwnerReference ownerReferenceObject);
    public WatchEventFluent.OwnerReferenceObjectNested withNewOwnerReferenceObject();
    public WatchEventFluent.OwnerReferenceObjectNested withNewOwnerReferenceObjectLike(OwnerReference item);
    public A withStorageOSPersistentVolumeSourceObject(StorageOSPersistentVolumeSource storageOSPersistentVolumeSourceObject);
    public WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested withNewStorageOSPersistentVolumeSourceObject();
    public WatchEventFluent.StorageOSPersistentVolumeSourceObjectNested withNewStorageOSPersistentVolumeSourceObjectLike(StorageOSPersistentVolumeSource 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 withPodAntiAffinityObject(PodAntiAffinity podAntiAffinityObject);
    public WatchEventFluent.PodAntiAffinityObjectNested withNewPodAntiAffinityObject();
    public WatchEventFluent.PodAntiAffinityObjectNested withNewPodAntiAffinityObjectLike(PodAntiAffinity item);
    public A withSecurityContextObject(SecurityContext securityContextObject);
    public WatchEventFluent.SecurityContextObjectNested withNewSecurityContextObject();
    public WatchEventFluent.SecurityContextObjectNested withNewSecurityContextObjectLike(SecurityContext item);
    public A withReplicationControllerListObject(ReplicationControllerList replicationControllerListObject);
    public WatchEventFluent.ReplicationControllerListObjectNested withNewReplicationControllerListObject();
    public WatchEventFluent.ReplicationControllerListObjectNested withNewReplicationControllerListObjectLike(ReplicationControllerList item);
    public A withConfigMapVolumeSourceObject(ConfigMapVolumeSource configMapVolumeSourceObject);
    public WatchEventFluent.ConfigMapVolumeSourceObjectNested withNewConfigMapVolumeSourceObject();
    public WatchEventFluent.ConfigMapVolumeSourceObjectNested withNewConfigMapVolumeSourceObjectLike(ConfigMapVolumeSource item);
    public A withContainerStateRunningObject(ContainerStateRunning containerStateRunningObject);
    public WatchEventFluent.ContainerStateRunningObjectNested withNewContainerStateRunningObject();
    public WatchEventFluent.ContainerStateRunningObjectNested withNewContainerStateRunningObjectLike(ContainerStateRunning item);
    public A withNewContainerStateRunningObject(String startedAt);
    public A withFlockerVolumeSourceObject(FlockerVolumeSource flockerVolumeSourceObject);
    public WatchEventFluent.FlockerVolumeSourceObjectNested withNewFlockerVolumeSourceObject();
    public WatchEventFluent.FlockerVolumeSourceObjectNested withNewFlockerVolumeSourceObjectLike(FlockerVolumeSource item);
    public A withNewFlockerVolumeSourceObject(String datasetName,String datasetUUID);
    public A withComponentStatusListObject(ComponentStatusList componentStatusListObject);
    public WatchEventFluent.ComponentStatusListObjectNested withNewComponentStatusListObject();
    public WatchEventFluent.ComponentStatusListObjectNested withNewComponentStatusListObjectLike(ComponentStatusList item);
    public A withScaleIOVolumeSourceObject(ScaleIOVolumeSource scaleIOVolumeSourceObject);
    public WatchEventFluent.ScaleIOVolumeSourceObjectNested withNewScaleIOVolumeSourceObject();
    public WatchEventFluent.ScaleIOVolumeSourceObjectNested withNewScaleIOVolumeSourceObjectLike(ScaleIOVolumeSource item);
    public A withLimitRangeListObject(LimitRangeList limitRangeListObject);
    public WatchEventFluent.LimitRangeListObjectNested withNewLimitRangeListObject();
    public WatchEventFluent.LimitRangeListObjectNested withNewLimitRangeListObjectLike(LimitRangeList item);
    public A withProbeObject(Probe probeObject);
    public WatchEventFluent.ProbeObjectNested withNewProbeObject();
    public WatchEventFluent.ProbeObjectNested withNewProbeObjectLike(Probe item);
    public A withUpdateOptionsObject(UpdateOptions updateOptionsObject);
    public WatchEventFluent.UpdateOptionsObjectNested withNewUpdateOptionsObject();
    public WatchEventFluent.UpdateOptionsObjectNested withNewUpdateOptionsObjectLike(UpdateOptions item);
    public A withEndpointsObject(Endpoints endpointsObject);
    public WatchEventFluent.EndpointsObjectNested withNewEndpointsObject();
    public WatchEventFluent.EndpointsObjectNested withNewEndpointsObjectLike(Endpoints item);
    public A withNamedExtensionObject(NamedExtension namedExtensionObject);
    public WatchEventFluent.NamedExtensionObjectNested withNewNamedExtensionObject();
    public WatchEventFluent.NamedExtensionObjectNested withNewNamedExtensionObjectLike(NamedExtension item);
    public A withAzureFilePersistentVolumeSourceObject(AzureFilePersistentVolumeSource azureFilePersistentVolumeSourceObject);
    public WatchEventFluent.AzureFilePersistentVolumeSourceObjectNested withNewAzureFilePersistentVolumeSourceObject();
    public WatchEventFluent.AzureFilePersistentVolumeSourceObjectNested withNewAzureFilePersistentVolumeSourceObjectLike(AzureFilePersistentVolumeSource item);
    public A withNewAzureFilePersistentVolumeSourceObject(Boolean readOnly,String secretName,String secretNamespace,String shareName);
    public A withSecretVolumeSourceObject(SecretVolumeSource secretVolumeSourceObject);
    public WatchEventFluent.SecretVolumeSourceObjectNested withNewSecretVolumeSourceObject();
    public WatchEventFluent.SecretVolumeSourceObjectNested withNewSecretVolumeSourceObjectLike(SecretVolumeSource item);
    public A withPodObject(Pod podObject);
    public WatchEventFluent.PodObjectNested withNewPodObject();
    public WatchEventFluent.PodObjectNested withNewPodObjectLike(Pod item);
    public A withClientIPConfigObject(ClientIPConfig clientIPConfigObject);
    public WatchEventFluent.ClientIPConfigObjectNested withNewClientIPConfigObject();
    public WatchEventFluent.ClientIPConfigObjectNested withNewClientIPConfigObjectLike(ClientIPConfig item);
    public A withNewClientIPConfigObject(Integer timeoutSeconds);
    public A withContextObject(Context contextObject);
    public WatchEventFluent.ContextObjectNested withNewContextObject();
    public WatchEventFluent.ContextObjectNested withNewContextObjectLike(Context item);
    public A withConfigMapObject(ConfigMap configMapObject);
    public WatchEventFluent.ConfigMapObjectNested withNewConfigMapObject();
    public WatchEventFluent.ConfigMapObjectNested withNewConfigMapObjectLike(ConfigMap item);
    public A withNodeAffinityObject(NodeAffinity nodeAffinityObject);
    public WatchEventFluent.NodeAffinityObjectNested withNewNodeAffinityObject();
    public WatchEventFluent.NodeAffinityObjectNested withNewNodeAffinityObjectLike(NodeAffinity 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 withPodListObject(PodList podListObject);
    public WatchEventFluent.PodListObjectNested withNewPodListObject();
    public WatchEventFluent.PodListObjectNested withNewPodListObjectLike(PodList item);
    public A withFCVolumeSourceObject(FCVolumeSource fCVolumeSourceObject);
    public WatchEventFluent.FCVolumeSourceObjectNested withNewFCVolumeSourceObject();
    public WatchEventFluent.FCVolumeSourceObjectNested withNewFCVolumeSourceObjectLike(FCVolumeSource item);
    public A withResourceFieldSelectorObject(ResourceFieldSelector resourceFieldSelectorObject);
    public WatchEventFluent.ResourceFieldSelectorObjectNested withNewResourceFieldSelectorObject();
    public WatchEventFluent.ResourceFieldSelectorObjectNested withNewResourceFieldSelectorObjectLike(ResourceFieldSelector item);
    public A withPersistentVolumeClaimSpecObject(PersistentVolumeClaimSpec persistentVolumeClaimSpecObject);
    public WatchEventFluent.PersistentVolumeClaimSpecObjectNested withNewPersistentVolumeClaimSpecObject();
    public WatchEventFluent.PersistentVolumeClaimSpecObjectNested withNewPersistentVolumeClaimSpecObjectLike(PersistentVolumeClaimSpec item);
    public A withLoadBalancerStatusObject(LoadBalancerStatus loadBalancerStatusObject);
    public WatchEventFluent.LoadBalancerStatusObjectNested withNewLoadBalancerStatusObject();
    public WatchEventFluent.LoadBalancerStatusObjectNested withNewLoadBalancerStatusObjectLike(LoadBalancerStatus item);
    public A withScopeSelectorObject(ScopeSelector scopeSelectorObject);
    public WatchEventFluent.ScopeSelectorObjectNested withNewScopeSelectorObject();
    public WatchEventFluent.ScopeSelectorObjectNested withNewScopeSelectorObjectLike(ScopeSelector item);
    public A withPodSecurityContextObject(PodSecurityContext podSecurityContextObject);
    public WatchEventFluent.PodSecurityContextObjectNested withNewPodSecurityContextObject();
    public WatchEventFluent.PodSecurityContextObjectNested withNewPodSecurityContextObjectLike(PodSecurityContext item);
    public A withDownwardAPIProjectionObject(DownwardAPIProjection downwardAPIProjectionObject);
    public WatchEventFluent.DownwardAPIProjectionObjectNested withNewDownwardAPIProjectionObject();
    public WatchEventFluent.DownwardAPIProjectionObjectNested withNewDownwardAPIProjectionObjectLike(DownwardAPIProjection item);
    public A withPodAffinityTermObject(PodAffinityTerm podAffinityTermObject);
    public WatchEventFluent.PodAffinityTermObjectNested withNewPodAffinityTermObject();
    public WatchEventFluent.PodAffinityTermObjectNested withNewPodAffinityTermObjectLike(PodAffinityTerm item);
    public A withServicePortObject(ServicePort servicePortObject);
    public WatchEventFluent.ServicePortObjectNested withNewServicePortObject();
    public WatchEventFluent.ServicePortObjectNested withNewServicePortObjectLike(ServicePort item);
    public A withGroupVersionForDiscoveryObject(GroupVersionForDiscovery groupVersionForDiscoveryObject);
    public WatchEventFluent.GroupVersionForDiscoveryObjectNested withNewGroupVersionForDiscoveryObject();
    public WatchEventFluent.GroupVersionForDiscoveryObjectNested withNewGroupVersionForDiscoveryObjectLike(GroupVersionForDiscovery item);
    public A withNewGroupVersionForDiscoveryObject(String groupVersion,String version);
    public A withPersistentVolumeClaimSourceObject(PersistentVolumeClaimVolumeSource persistentVolumeClaimSourceObject);
    public WatchEventFluent.PersistentVolumeClaimSourceObjectNested withNewPersistentVolumeClaimSourceObject();
    public WatchEventFluent.PersistentVolumeClaimSourceObjectNested withNewPersistentVolumeClaimSourceObjectLike(PersistentVolumeClaimVolumeSource item);
    public A withNewPersistentVolumeClaimSourceObject(String claimName,Boolean readOnly);
    public A withSessionAffinityConfigObject(SessionAffinityConfig sessionAffinityConfigObject);
    public WatchEventFluent.SessionAffinityConfigObjectNested withNewSessionAffinityConfigObject();
    public WatchEventFluent.SessionAffinityConfigObjectNested withNewSessionAffinityConfigObjectLike(SessionAffinityConfig 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 withDaemonEndpointObject(DaemonEndpoint daemonEndpointObject);
    public WatchEventFluent.DaemonEndpointObjectNested withNewDaemonEndpointObject();
    public WatchEventFluent.DaemonEndpointObjectNested withNewDaemonEndpointObjectLike(DaemonEndpoint item);
    public A withNewDaemonEndpointObject(Integer port);
    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 withFlexPersistentVolumeSourceObject(FlexPersistentVolumeSource flexPersistentVolumeSourceObject);
    public WatchEventFluent.FlexPersistentVolumeSourceObjectNested withNewFlexPersistentVolumeSourceObject();
    public WatchEventFluent.FlexPersistentVolumeSourceObjectNested withNewFlexPersistentVolumeSourceObjectLike(FlexPersistentVolumeSource item);
    public A withNamespaceListObject(NamespaceList namespaceListObject);
    public WatchEventFluent.NamespaceListObjectNested withNewNamespaceListObject();
    public WatchEventFluent.NamespaceListObjectNested withNewNamespaceListObjectLike(NamespaceList item);
    public A withPodDNSConfigObject(PodDNSConfig podDNSConfigObject);
    public WatchEventFluent.PodDNSConfigObjectNested withNewPodDNSConfigObject();
    public WatchEventFluent.PodDNSConfigObjectNested withNewPodDNSConfigObjectLike(PodDNSConfig item);
    public A withNodeListObject(NodeList nodeListObject);
    public WatchEventFluent.NodeListObjectNested withNewNodeListObject();
    public WatchEventFluent.NodeListObjectNested withNewNodeListObjectLike(NodeList item);
    public A withBindingObject(Binding bindingObject);
    public WatchEventFluent.BindingObjectNested withNewBindingObject();
    public WatchEventFluent.BindingObjectNested withNewBindingObjectLike(Binding item);
    public A withVolumeProjectionObject(VolumeProjection volumeProjectionObject);
    public WatchEventFluent.VolumeProjectionObjectNested withNewVolumeProjectionObject();
    public WatchEventFluent.VolumeProjectionObjectNested withNewVolumeProjectionObjectLike(VolumeProjection item);
    public A withEnvVarSourceObject(EnvVarSource envVarSourceObject);
    public WatchEventFluent.EnvVarSourceObjectNested withNewEnvVarSourceObject();
    public WatchEventFluent.EnvVarSourceObjectNested withNewEnvVarSourceObjectLike(EnvVarSource item);
    public A withResourceQuotaObject(ResourceQuota resourceQuotaObject);
    public WatchEventFluent.ResourceQuotaObjectNested withNewResourceQuotaObject();
    public WatchEventFluent.ResourceQuotaObjectNested withNewResourceQuotaObjectLike(ResourceQuota item);
    public A withSecretObject(Secret secretObject);
    public WatchEventFluent.SecretObjectNested withNewSecretObject();
    public WatchEventFluent.SecretObjectNested withNewSecretObjectLike(Secret item);
    public A withServiceListObject(ServiceList serviceListObject);
    public WatchEventFluent.ServiceListObjectNested withNewServiceListObject();
    public WatchEventFluent.ServiceListObjectNested withNewServiceListObjectLike(ServiceList item);
    public A withVolumeNodeAffinityObject(VolumeNodeAffinity volumeNodeAffinityObject);
    public WatchEventFluent.VolumeNodeAffinityObjectNested withNewVolumeNodeAffinityObject();
    public WatchEventFluent.VolumeNodeAffinityObjectNested withNewVolumeNodeAffinityObjectLike(VolumeNodeAffinity item);
    public A withResourceQuotaSpecObject(ResourceQuotaSpec resourceQuotaSpecObject);
    public WatchEventFluent.ResourceQuotaSpecObjectNested withNewResourceQuotaSpecObject();
    public WatchEventFluent.ResourceQuotaSpecObjectNested withNewResourceQuotaSpecObjectLike(ResourceQuotaSpec item);
    public A withNodeSelectorTermObject(NodeSelectorTerm nodeSelectorTermObject);
    public WatchEventFluent.NodeSelectorTermObjectNested withNewNodeSelectorTermObject();
    public WatchEventFluent.NodeSelectorTermObjectNested withNewNodeSelectorTermObjectLike(NodeSelectorTerm item);
    public A withScaleIOPersistentVolumeSourceObject(ScaleIOPersistentVolumeSource scaleIOPersistentVolumeSourceObject);
    public WatchEventFluent.ScaleIOPersistentVolumeSourceObjectNested withNewScaleIOPersistentVolumeSourceObject();
    public WatchEventFluent.ScaleIOPersistentVolumeSourceObjectNested withNewScaleIOPersistentVolumeSourceObjectLike(ScaleIOPersistentVolumeSource item);
    public A withListOptionsObject(ListOptions listOptionsObject);
    public WatchEventFluent.ListOptionsObjectNested withNewListOptionsObject();
    public WatchEventFluent.ListOptionsObjectNested withNewListOptionsObjectLike(ListOptions item);
    public A withWeightedPodAffinityTermObject(WeightedPodAffinityTerm weightedPodAffinityTermObject);
    public WatchEventFluent.WeightedPodAffinityTermObjectNested withNewWeightedPodAffinityTermObject();
    public WatchEventFluent.WeightedPodAffinityTermObjectNested withNewWeightedPodAffinityTermObjectLike(WeightedPodAffinityTerm item);
    public A withBaseKubernetesListObject(BaseKubernetesList baseKubernetesListObject);
    public WatchEventFluent.BaseKubernetesListObjectNested withNewBaseKubernetesListObject();
    public WatchEventFluent.BaseKubernetesListObjectNested withNewBaseKubernetesListObjectLike(BaseKubernetesList item);
    public A withNodeSystemInfoObject(NodeSystemInfo nodeSystemInfoObject);
    public WatchEventFluent.NodeSystemInfoObjectNested withNewNodeSystemInfoObject();
    public WatchEventFluent.NodeSystemInfoObjectNested withNewNodeSystemInfoObjectLike(NodeSystemInfo item);
    public A withTopologySelectorLabelRequirementObject(TopologySelectorLabelRequirement topologySelectorLabelRequirementObject);
    public WatchEventFluent.TopologySelectorLabelRequirementObjectNested withNewTopologySelectorLabelRequirementObject();
    public WatchEventFluent.TopologySelectorLabelRequirementObjectNested withNewTopologySelectorLabelRequirementObjectLike(TopologySelectorLabelRequirement item);
    public A withRBDPersistentVolumeSourceObject(RBDPersistentVolumeSource rBDPersistentVolumeSourceObject);
    public WatchEventFluent.RBDPersistentVolumeSourceObjectNested withNewRBDPersistentVolumeSourceObject();
    public WatchEventFluent.RBDPersistentVolumeSourceObjectNested withNewRBDPersistentVolumeSourceObjectLike(RBDPersistentVolumeSource 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 withAuthProviderConfigObject(AuthProviderConfig authProviderConfigObject);
    public WatchEventFluent.AuthProviderConfigObjectNested withNewAuthProviderConfigObject();
    public WatchEventFluent.AuthProviderConfigObjectNested withNewAuthProviderConfigObjectLike(AuthProviderConfig item);
    public A withHostAliasObject(HostAlias hostAliasObject);
    public WatchEventFluent.HostAliasObjectNested withNewHostAliasObject();
    public WatchEventFluent.HostAliasObjectNested withNewHostAliasObjectLike(HostAlias item);
    public A withNodeDaemonEndpointsObject(NodeDaemonEndpoints nodeDaemonEndpointsObject);
    public WatchEventFluent.NodeDaemonEndpointsObjectNested withNewNodeDaemonEndpointsObject();
    public WatchEventFluent.NodeDaemonEndpointsObjectNested withNewNodeDaemonEndpointsObjectLike(NodeDaemonEndpoints item);
    public A withCSIVolumeSourceObject(CSIVolumeSource cSIVolumeSourceObject);
    public WatchEventFluent.CSIVolumeSourceObjectNested withNewCSIVolumeSourceObject();
    public WatchEventFluent.CSIVolumeSourceObjectNested withNewCSIVolumeSourceObjectLike(CSIVolumeSource item);
    public A withVolumeDeviceObject(VolumeDevice volumeDeviceObject);
    public WatchEventFluent.VolumeDeviceObjectNested withNewVolumeDeviceObject();
    public WatchEventFluent.VolumeDeviceObjectNested withNewVolumeDeviceObjectLike(VolumeDevice item);
    public A withNewVolumeDeviceObject(String devicePath,String name);
    public A withPersistentVolumeSpecObject(PersistentVolumeSpec persistentVolumeSpecObject);
    public WatchEventFluent.PersistentVolumeSpecObjectNested withNewPersistentVolumeSpecObject();
    public WatchEventFluent.PersistentVolumeSpecObjectNested withNewPersistentVolumeSpecObjectLike(PersistentVolumeSpec item);
    public A withNodeObject(Node nodeObject);
    public WatchEventFluent.NodeObjectNested withNewNodeObject();
    public WatchEventFluent.NodeObjectNested withNewNodeObjectLike(Node item);
    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 withVolumeObject(Volume volumeObject);
    public WatchEventFluent.VolumeObjectNested withNewVolumeObject();
    public WatchEventFluent.VolumeObjectNested withNewVolumeObjectLike(Volume item);
    public A withClusterObject(Cluster clusterObject);
    public WatchEventFluent.ClusterObjectNested withNewClusterObject();
    public WatchEventFluent.ClusterObjectNested withNewClusterObjectLike(Cluster item);
    public A withStorageOSVolumeSourceObject(StorageOSVolumeSource storageOSVolumeSourceObject);
    public WatchEventFluent.StorageOSVolumeSourceObjectNested withNewStorageOSVolumeSourceObject();
    public WatchEventFluent.StorageOSVolumeSourceObjectNested withNewStorageOSVolumeSourceObjectLike(StorageOSVolumeSource item);
    public A withExecConfigObject(ExecConfig execConfigObject);
    public WatchEventFluent.ExecConfigObjectNested withNewExecConfigObject();
    public WatchEventFluent.ExecConfigObjectNested withNewExecConfigObjectLike(ExecConfig item);
    public A withKubernetesListObject(KubernetesList kubernetesListObject);
    public WatchEventFluent.KubernetesListObjectNested withNewKubernetesListObject();
    public WatchEventFluent.KubernetesListObjectNested withNewKubernetesListObjectLike(KubernetesList item);
    public A withPodStatusObject(PodStatus podStatusObject);
    public WatchEventFluent.PodStatusObjectNested withNewPodStatusObject();
    public WatchEventFluent.PodStatusObjectNested withNewPodStatusObjectLike(PodStatus 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 withEndpointPortObject(EndpointPort endpointPortObject);
    public WatchEventFluent.EndpointPortObjectNested withNewEndpointPortObject();
    public WatchEventFluent.EndpointPortObjectNested withNewEndpointPortObjectLike(EndpointPort item);
    public A withNewEndpointPortObject(String appProtocol,String name,Integer port,String protocol);
    public A withCapabilitiesObject(Capabilities capabilitiesObject);
    public WatchEventFluent.CapabilitiesObjectNested withNewCapabilitiesObject();
    public WatchEventFluent.CapabilitiesObjectNested withNewCapabilitiesObjectLike(Capabilities 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 withWatchEventObject(WatchEvent watchEventObject);
    public WatchEventFluent.WatchEventObjectNested withNewWatchEventObject();
    public WatchEventFluent.WatchEventObjectNested withNewWatchEventObjectLike(WatchEvent item);
    public A withObjectReferenceObject(ObjectReference objectReferenceObject);
    public WatchEventFluent.ObjectReferenceObjectNested withNewObjectReferenceObject();
    public WatchEventFluent.ObjectReferenceObjectNested withNewObjectReferenceObjectLike(ObjectReference item);
    public A withLimitRangeItemObject(LimitRangeItem limitRangeItemObject);
    public WatchEventFluent.LimitRangeItemObjectNested withNewLimitRangeItemObject();
    public WatchEventFluent.LimitRangeItemObjectNested withNewLimitRangeItemObjectLike(LimitRangeItem item);
    public A withSecretProjectionObject(SecretProjection secretProjectionObject);
    public WatchEventFluent.SecretProjectionObjectNested withNewSecretProjectionObject();
    public WatchEventFluent.SecretProjectionObjectNested withNewSecretProjectionObjectLike(SecretProjection item);
    public A withGetOptionsObject(GetOptions getOptionsObject);
    public WatchEventFluent.GetOptionsObjectNested withNewGetOptionsObject();
    public WatchEventFluent.GetOptionsObjectNested withNewGetOptionsObjectLike(GetOptions item);
    public A withNewGetOptionsObject(String apiVersion,String kind,String resourceVersion);
    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 withManagedFieldsEntryObject(ManagedFieldsEntry managedFieldsEntryObject);
    public WatchEventFluent.ManagedFieldsEntryObjectNested withNewManagedFieldsEntryObject();
    public WatchEventFluent.ManagedFieldsEntryObjectNested withNewManagedFieldsEntryObjectLike(ManagedFieldsEntry item);
    public A withNamespaceStatusObject(NamespaceStatus namespaceStatusObject);
    public WatchEventFluent.NamespaceStatusObjectNested withNewNamespaceStatusObject();
    public WatchEventFluent.NamespaceStatusObjectNested withNewNamespaceStatusObjectLike(NamespaceStatus 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 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 withServiceAccountObject(ServiceAccount serviceAccountObject);
    public WatchEventFluent.ServiceAccountObjectNested withNewServiceAccountObject();
    public WatchEventFluent.ServiceAccountObjectNested withNewServiceAccountObjectLike(ServiceAccount item);
    public A withPodIPObject(PodIP podIPObject);
    public WatchEventFluent.PodIPObjectNested withNewPodIPObject();
    public WatchEventFluent.PodIPObjectNested withNewPodIPObjectLike(PodIP item);
    public A withNewPodIPObject(String ip);
    public String getType();
    public A withType(String type);
    public Boolean hasType();
    public A withNewType(String arg1);
    public A withNewType(StringBuilder arg1);
    public A withNewType(StringBuffer arg1);

    public interface PatchObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PatchFluent>{

        
    public N and();    public N endPatchObject();
}
    public interface LimitRangeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LimitRangeFluent>{

        
    public N and();    public N endLimitRangeObject();
}
    public interface APIGroupListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,APIGroupListFluent>{

        
    public N and();    public N endAPIGroupListObject();
}
    public interface PodTemplateSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodTemplateSpecFluent>{

        
    public N and();    public N endPodTemplateSpecObject();
}
    public interface CSIPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CSIPersistentVolumeSourceFluent>{

        
    public N and();    public N endCSIPersistentVolumeSourceObject();
}
    public interface AuthInfoObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AuthInfoFluent>{

        
    public N and();    public N endAuthInfoObject();
}
    public interface ResourceRequirementsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ResourceRequirementsFluent>{

        
    public N and();    public N endResourceRequirementsObject();
}
    public interface ConfigMapKeySelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapKeySelectorFluent>{

        
    public N and();    public N endConfigMapKeySelectorObject();
}
    public interface HostPathVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,HostPathVolumeSourceFluent>{

        
    public N and();    public N endHostPathVolumeSourceObject();
}
    public interface NamedContextObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamedContextFluent>{

        
    public N and();    public N endNamedContextObject();
}
    public interface PersistentVolumeClaimListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeClaimListFluent>{

        
    public N and();    public N endPersistentVolumeClaimListObject();
}
    public interface ConfigObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigFluent>{

        
    public N and();    public N endConfigObject();
}
    public interface AffinityObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AffinityFluent>{

        
    public N and();    public N endAffinityObject();
}
    public interface ReplicationControllerStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ReplicationControllerStatusFluent>{

        
    public N and();    public N endReplicationControllerStatusObject();
}
    public interface MicroTimeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,MicroTimeFluent>{

        
    public N and();    public N endMicroTimeObject();
}
    public interface LifecycleObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LifecycleFluent>{

        
    public N and();    public N endLifecycleObject();
}
    public interface PortworxVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PortworxVolumeSourceFluent>{

        
    public N and();    public N endPortworxVolumeSourceObject();
}
    public interface EventSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EventSourceFluent>{

        
    public N and();    public N endEventSourceObject();
}
    public interface AzureFileVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AzureFileVolumeSourceFluent>{

        
    public N and();    public N endAzureFileVolumeSourceObject();
}
    public interface ComponentConditionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ComponentConditionFluent>{

        
    public N and();    public N endComponentConditionObject();
}
    public interface EnvVarObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EnvVarFluent>{

        
    public N and();    public N endEnvVarObject();
}
    public interface ReplicationControllerSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ReplicationControllerSpecFluent>{

        
    public N and();    public N endReplicationControllerSpecObject();
}
    public interface LoadBalancerIngressObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LoadBalancerIngressFluent>{

        
    public N and();    public N endLoadBalancerIngressObject();
}
    public interface AttachedVolumeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AttachedVolumeFluent>{

        
    public N and();    public N endAttachedVolumeObject();
}
    public interface LocalObjectReferenceNested extends io.fabric8.kubernetes.api.builder.Nested,LocalObjectReferenceFluent>{

        
    public N and();    public N endLocalObjectReference();
}
    public interface NamedAuthInfoObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamedAuthInfoFluent>{

        
    public N and();    public N endNamedAuthInfoObject();
}
    public interface EmptyDirVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EmptyDirVolumeSourceFluent>{

        
    public N and();    public N endEmptyDirVolumeSourceObject();
}
    public interface PodSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodSpecFluent>{

        
    public N and();    public N endPodSpecObject();
}
    public interface ServerAddressByClientCIDRObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServerAddressByClientCIDRFluent>{

        
    public N and();    public N endServerAddressByClientCIDRObject();
}
    public interface AzureDiskVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AzureDiskVolumeSourceFluent>{

        
    public N and();    public N endAzureDiskVolumeSourceObject();
}
    public interface PreconditionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PreconditionsFluent>{

        
    public N and();    public N endPreconditionsObject();
}
    public interface InfoObjectNested extends io.fabric8.kubernetes.api.builder.Nested,InfoFluent>{

        
    public N and();    public N endInfoObject();
}
    public interface CephFSVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CephFSVolumeSourceFluent>{

        
    public N and();    public N endCephFSVolumeSourceObject();
}
    public interface EphemeralContainerObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EphemeralContainerFluent>{

        
    public N and();    public N endEphemeralContainerObject();
}
    public interface NodeConditionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeConditionFluent>{

        
    public N and();    public N endNodeConditionObject();
}
    public interface EndpointSubsetObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EndpointSubsetFluent>{

        
    public N and();    public N endEndpointSubsetObject();
}
    public interface LocalVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LocalVolumeSourceFluent>{

        
    public N and();    public N endLocalVolumeSourceObject();
}
    public interface ServiceStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceStatusFluent>{

        
    public N and();    public N endServiceStatusObject();
}
    public interface TaintObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TaintFluent>{

        
    public N and();    public N endTaintObject();
}
    public interface PatchOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PatchOptionsFluent>{

        
    public N and();    public N endPatchOptionsObject();
}
    public interface ConfigMapNodeConfigSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapNodeConfigSourceFluent>{

        
    public N and();    public N endConfigMapNodeConfigSourceObject();
}
    public interface HTTPGetActionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,HTTPGetActionFluent>{

        
    public N and();    public N endHTTPGetActionObject();
}
    public interface GlusterfsPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GlusterfsPersistentVolumeSourceFluent>{

        
    public N and();    public N endGlusterfsPersistentVolumeSourceObject();
}
    public interface DownwardAPIVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,DownwardAPIVolumeSourceFluent>{

        
    public N and();    public N endDownwardAPIVolumeSourceObject();
}
    public interface ISCSIPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ISCSIPersistentVolumeSourceFluent>{

        
    public N and();    public N endISCSIPersistentVolumeSourceObject();
}
    public interface WindowsSecurityContextOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,WindowsSecurityContextOptionsFluent>{

        
    public N and();    public N endWindowsSecurityContextOptionsObject();
}
    public interface EnvFromSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EnvFromSourceFluent>{

        
    public N and();    public N endEnvFromSourceObject();
}
    public interface CreateOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CreateOptionsFluent>{

        
    public N and();    public N endCreateOptionsObject();
}
    public interface NamespaceSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamespaceSpecFluent>{

        
    public N and();    public N endNamespaceSpecObject();
}
    public interface ListMetaObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ListMetaFluent>{

        
    public N and();    public N endListMetaObject();
}
    public interface RootPathsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,RootPathsFluent>{

        
    public N and();    public N endRootPathsObject();
}
    public interface TypeMetaObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TypeMetaFluent>{

        
    public N and();    public N endTypeMetaObject();
}
    public interface SecretReferenceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretReferenceFluent>{

        
    public N and();    public N endSecretReferenceObject();
}
    public interface APIGroupObjectNested extends io.fabric8.kubernetes.api.builder.Nested,APIGroupFluent>{

        
    public N and();    public N endAPIGroupObject();
}
    public interface FlexVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,FlexVolumeSourceFluent>{

        
    public N and();    public N endFlexVolumeSourceObject();
}
    public interface ISCSIVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ISCSIVolumeSourceFluent>{

        
    public N and();    public N endISCSIVolumeSourceObject();
}
    public interface SecretKeySelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretKeySelectorFluent>{

        
    public N and();    public N endSecretKeySelectorObject();
}
    public interface RBDVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,RBDVolumeSourceFluent>{

        
    public N and();    public N endRBDVolumeSourceObject();
}
    public interface ResourceQuotaListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ResourceQuotaListFluent>{

        
    public N and();    public N endResourceQuotaListObject();
}
    public interface NodeConfigStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeConfigStatusFluent>{

        
    public N and();    public N endNodeConfigStatusObject();
}
    public interface QuobyteVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,QuobyteVolumeSourceFluent>{

        
    public N and();    public N endQuobyteVolumeSourceObject();
}
    public interface ResourceQuotaStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ResourceQuotaStatusFluent>{

        
    public N and();    public N endResourceQuotaStatusObject();
}
    public interface ConfigMapProjectionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapProjectionFluent>{

        
    public N and();    public N endConfigMapProjectionObject();
}
    public interface ScopedResourceSelectorRequirementObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ScopedResourceSelectorRequirementFluent>{

        
    public N and();    public N endScopedResourceSelectorRequirementObject();
}
    public interface NamespaceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamespaceFluent>{

        
    public N and();    public N endNamespaceObject();
}
    public interface ContainerStateTerminatedObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerStateTerminatedFluent>{

        
    public N and();    public N endContainerStateTerminatedObject();
}
    public interface GroupVersionKindObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GroupVersionKindFluent>{

        
    public N and();    public N endGroupVersionKindObject();
}
    public interface LimitRangeSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LimitRangeSpecFluent>{

        
    public N and();    public N endLimitRangeSpecObject();
}
    public interface ProjectedVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ProjectedVolumeSourceFluent>{

        
    public N and();    public N endProjectedVolumeSourceObject();
}
    public interface HandlerObjectNested extends io.fabric8.kubernetes.api.builder.Nested,HandlerFluent>{

        
    public N and();    public N endHandlerObject();
}
    public interface PersistentVolumeClaimStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeClaimStatusFluent>{

        
    public N and();    public N endPersistentVolumeClaimStatusObject();
}
    public interface ContainerStateObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerStateFluent>{

        
    public N and();    public N endContainerStateObject();
}
    public interface ServiceSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceSpecFluent>{

        
    public N and();    public N endServiceSpecObject();
}
    public interface ServiceAccountTokenProjectionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceAccountTokenProjectionFluent>{

        
    public N and();    public N endServiceAccountTokenProjectionObject();
}
    public interface PhotonPersistentDiskVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PhotonPersistentDiskVolumeSourceFluent>{

        
    public N and();    public N endPhotonPersistentDiskVolumeSourceObject();
}
    public interface ContainerObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerFluent>{

        
    public N and();    public N endContainerObject();
}
    public interface NodeSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeSpecFluent>{

        
    public N and();    public N endNodeSpecObject();
}
    public interface TypedLocalObjectReferenceNested extends io.fabric8.kubernetes.api.builder.Nested,TypedLocalObjectReferenceFluent>{

        
    public N and();    public N endTypedLocalObjectReference();
}
    public interface FieldsV1ObjectNested extends io.fabric8.kubernetes.api.builder.Nested,FieldsV1Fluent>{

        
    public N and();    public N endFieldsV1Object();
}
    public interface SecretListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretListFluent>{

        
    public N and();    public N endSecretListObject();
}
    public interface NodeAddressObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeAddressFluent>{

        
    public N and();    public N endNodeAddressObject();
}
    public interface PodAffinityObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodAffinityFluent>{

        
    public N and();    public N endPodAffinityObject();
}
    public interface ExecEnvVarObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ExecEnvVarFluent>{

        
    public N and();    public N endExecEnvVarObject();
}
    public interface ServiceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceFluent>{

        
    public N and();    public N endServiceObject();
}
    public interface PodConditionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodConditionFluent>{

        
    public N and();    public N endPodConditionObject();
}
    public interface TopologySpreadConstraintObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TopologySpreadConstraintFluent>{

        
    public N and();    public N endTopologySpreadConstraintObject();
}
    public interface ExecActionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ExecActionFluent>{

        
    public N and();    public N endExecActionObject();
}
    public interface ContainerImageObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerImageFluent>{

        
    public N and();    public N endContainerImageObject();
}
    public interface ReplicationControllerObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ReplicationControllerFluent>{

        
    public N and();    public N endReplicationControllerObject();
}
    public interface NodeStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeStatusFluent>{

        
    public N and();    public N endNodeStatusObject();
}
    public interface ConfigMapListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapListFluent>{

        
    public N and();    public N endConfigMapListObject();
}
    public interface NodeSelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeSelectorFluent>{

        
    public N and();    public N endNodeSelectorObject();
}
    public interface TolerationObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TolerationFluent>{

        
    public N and();    public N endTolerationObject();
}
    public interface CephFSPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CephFSPersistentVolumeSourceFluent>{

        
    public N and();    public N endCephFSPersistentVolumeSourceObject();
}
    public interface PersistentVolumeClaimConditionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeClaimConditionFluent>{

        
    public N and();    public N endPersistentVolumeClaimConditionObject();
}
    public interface PreferredSchedulingTermObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PreferredSchedulingTermFluent>{

        
    public N and();    public N endPreferredSchedulingTermObject();
}
    public interface PersistentVolumeListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeListFluent>{

        
    public N and();    public N endPersistentVolumeListObject();
}
    public interface GCEPersistentDiskVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GCEPersistentDiskVolumeSourceFluent>{

        
    public N and();    public N endGCEPersistentDiskVolumeSourceObject();
}
    public interface PodDNSConfigOptionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodDNSConfigOptionFluent>{

        
    public N and();    public N endPodDNSConfigOptionObject();
}
    public interface PodReadinessGateObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodReadinessGateFluent>{

        
    public N and();    public N endPodReadinessGateObject();
}
    public interface ContainerStateWaitingObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerStateWaitingFluent>{

        
    public N and();    public N endContainerStateWaitingObject();
}
    public interface VolumeMountObjectNested extends io.fabric8.kubernetes.api.builder.Nested,VolumeMountFluent>{

        
    public N and();    public N endVolumeMountObject();
}
    public interface NamespaceConditionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamespaceConditionFluent>{

        
    public N and();    public N endNamespaceConditionObject();
}
    public interface LabelSelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LabelSelectorFluent>{

        
    public N and();    public N endLabelSelectorObject();
}
    public interface StatusCauseObjectNested extends io.fabric8.kubernetes.api.builder.Nested,StatusCauseFluent>{

        
    public N and();    public N endStatusCauseObject();
}
    public interface NamedClusterObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamedClusterFluent>{

        
    public N and();    public N endNamedClusterObject();
}
    public interface StatusDetailsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,StatusDetailsFluent>{

        
    public N and();    public N endStatusDetailsObject();
}
    public interface DownwardAPIVolumeFileObjectNested extends io.fabric8.kubernetes.api.builder.Nested,DownwardAPIVolumeFileFluent>{

        
    public N and();    public N endDownwardAPIVolumeFileObject();
}
    public interface SysctlObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SysctlFluent>{

        
    public N and();    public N endSysctlObject();
}
    public interface DeleteOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,DeleteOptionsFluent>{

        
    public N and();    public N endDeleteOptionsObject();
}
    public interface StatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,StatusFluent>{

        
    public N and();    public N endStatusObject();
}
    public interface ContainerStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerStatusFluent>{

        
    public N and();    public N endContainerStatusObject();
}
    public interface PodTemplateObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodTemplateFluent>{

        
    public N and();    public N endPodTemplateObject();
}
    public interface ConfigMapEnvSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapEnvSourceFluent>{

        
    public N and();    public N endConfigMapEnvSourceObject();
}
    public interface NodeSelectorRequirementObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeSelectorRequirementFluent>{

        
    public N and();    public N endNodeSelectorRequirementObject();
}
    public interface TCPSocketActionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TCPSocketActionFluent>{

        
    public N and();    public N endTCPSocketActionObject();
}
    public interface PreferencesObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PreferencesFluent>{

        
    public N and();    public N endPreferencesObject();
}
    public interface ObjectFieldSelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ObjectFieldSelectorFluent>{

        
    public N and();    public N endObjectFieldSelectorObject();
}
    public interface PodTemplateListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodTemplateListFluent>{

        
    public N and();    public N endPodTemplateListObject();
}
    public interface PersistentVolumeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeFluent>{

        
    public N and();    public N endPersistentVolumeObject();
}
    public interface EndpointAddressObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EndpointAddressFluent>{

        
    public N and();    public N endEndpointAddressObject();
}
    public interface CinderVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CinderVolumeSourceFluent>{

        
    public N and();    public N endCinderVolumeSourceObject();
}
    public interface NodeConfigSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeConfigSourceFluent>{

        
    public N and();    public N endNodeConfigSourceObject();
}
    public interface VsphereVirtualDiskVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,VsphereVirtualDiskVolumeSourceFluent>{

        
    public N and();    public N endVsphereVirtualDiskVolumeSourceObject();
}
    public interface ObjectMetaObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ObjectMetaFluent>{

        
    public N and();    public N endObjectMetaObject();
}
    public interface PersistentVolumeClaimObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeClaimFluent>{

        
    public N and();    public N endPersistentVolumeClaimObject();
}
    public interface LabelSelectorRequirementObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LabelSelectorRequirementFluent>{

        
    public N and();    public N endLabelSelectorRequirementObject();
}
    public interface GitRepoVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GitRepoVolumeSourceFluent>{

        
    public N and();    public N endGitRepoVolumeSourceObject();
}
    public interface EndpointsListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EndpointsListFluent>{

        
    public N and();    public N endEndpointsListObject();
}
    public interface GroupVersionResourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GroupVersionResourceFluent>{

        
    public N and();    public N endGroupVersionResourceObject();
}
    public interface CinderPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CinderPersistentVolumeSourceFluent>{

        
    public N and();    public N endCinderPersistentVolumeSourceObject();
}
    public interface TopologySelectorTermObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TopologySelectorTermFluent>{

        
    public N and();    public N endTopologySelectorTermObject();
}
    public interface OwnerReferenceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,OwnerReferenceFluent>{

        
    public N and();    public N endOwnerReferenceObject();
}
    public interface StorageOSPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,StorageOSPersistentVolumeSourceFluent>{

        
    public N and();    public N endStorageOSPersistentVolumeSourceObject();
}
    public interface ReplicationControllerConditionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ReplicationControllerConditionFluent>{

        
    public N and();    public N endReplicationControllerConditionObject();
}
    public interface PodAntiAffinityObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodAntiAffinityFluent>{

        
    public N and();    public N endPodAntiAffinityObject();
}
    public interface SecurityContextObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecurityContextFluent>{

        
    public N and();    public N endSecurityContextObject();
}
    public interface ReplicationControllerListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ReplicationControllerListFluent>{

        
    public N and();    public N endReplicationControllerListObject();
}
    public interface ConfigMapVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapVolumeSourceFluent>{

        
    public N and();    public N endConfigMapVolumeSourceObject();
}
    public interface ContainerStateRunningObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerStateRunningFluent>{

        
    public N and();    public N endContainerStateRunningObject();
}
    public interface FlockerVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,FlockerVolumeSourceFluent>{

        
    public N and();    public N endFlockerVolumeSourceObject();
}
    public interface ComponentStatusListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ComponentStatusListFluent>{

        
    public N and();    public N endComponentStatusListObject();
}
    public interface ScaleIOVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ScaleIOVolumeSourceFluent>{

        
    public N and();    public N endScaleIOVolumeSourceObject();
}
    public interface LimitRangeListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LimitRangeListFluent>{

        
    public N and();    public N endLimitRangeListObject();
}
    public interface ProbeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ProbeFluent>{

        
    public N and();    public N endProbeObject();
}
    public interface UpdateOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,UpdateOptionsFluent>{

        
    public N and();    public N endUpdateOptionsObject();
}
    public interface EndpointsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EndpointsFluent>{

        
    public N and();    public N endEndpointsObject();
}
    public interface NamedExtensionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamedExtensionFluent>{

        
    public N and();    public N endNamedExtensionObject();
}
    public interface AzureFilePersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AzureFilePersistentVolumeSourceFluent>{

        
    public N and();    public N endAzureFilePersistentVolumeSourceObject();
}
    public interface SecretVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretVolumeSourceFluent>{

        
    public N and();    public N endSecretVolumeSourceObject();
}
    public interface PodObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodFluent>{

        
    public N and();    public N endPodObject();
}
    public interface ClientIPConfigObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ClientIPConfigFluent>{

        
    public N and();    public N endClientIPConfigObject();
}
    public interface ContextObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContextFluent>{

        
    public N and();    public N endContextObject();
}
    public interface ConfigMapObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ConfigMapFluent>{

        
    public N and();    public N endConfigMapObject();
}
    public interface NodeAffinityObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeAffinityFluent>{

        
    public N and();    public N endNodeAffinityObject();
}
    public interface ContainerPortObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ContainerPortFluent>{

        
    public N and();    public N endContainerPortObject();
}
    public interface PodListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodListFluent>{

        
    public N and();    public N endPodListObject();
}
    public interface FCVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,FCVolumeSourceFluent>{

        
    public N and();    public N endFCVolumeSourceObject();
}
    public interface ResourceFieldSelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ResourceFieldSelectorFluent>{

        
    public N and();    public N endResourceFieldSelectorObject();
}
    public interface PersistentVolumeClaimSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeClaimSpecFluent>{

        
    public N and();    public N endPersistentVolumeClaimSpecObject();
}
    public interface LoadBalancerStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LoadBalancerStatusFluent>{

        
    public N and();    public N endLoadBalancerStatusObject();
}
    public interface ScopeSelectorObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ScopeSelectorFluent>{

        
    public N and();    public N endScopeSelectorObject();
}
    public interface PodSecurityContextObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodSecurityContextFluent>{

        
    public N and();    public N endPodSecurityContextObject();
}
    public interface DownwardAPIProjectionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,DownwardAPIProjectionFluent>{

        
    public N and();    public N endDownwardAPIProjectionObject();
}
    public interface PodAffinityTermObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodAffinityTermFluent>{

        
    public N and();    public N endPodAffinityTermObject();
}
    public interface ServicePortObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServicePortFluent>{

        
    public N and();    public N endServicePortObject();
}
    public interface GroupVersionForDiscoveryObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GroupVersionForDiscoveryFluent>{

        
    public N and();    public N endGroupVersionForDiscoveryObject();
}
    public interface PersistentVolumeClaimSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeClaimVolumeSourceFluent>{

        
    public N and();    public N endPersistentVolumeClaimSourceObject();
}
    public interface SessionAffinityConfigObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SessionAffinityConfigFluent>{

        
    public N and();    public N endSessionAffinityConfigObject();
}
    public interface ServiceAccountListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceAccountListFluent>{

        
    public N and();    public N endServiceAccountListObject();
}
    public interface ComponentStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ComponentStatusFluent>{

        
    public N and();    public N endComponentStatusObject();
}
    public interface DaemonEndpointObjectNested extends io.fabric8.kubernetes.api.builder.Nested,DaemonEndpointFluent>{

        
    public N and();    public N endDaemonEndpointObject();
}
    public interface KeyToPathObjectNested extends io.fabric8.kubernetes.api.builder.Nested,KeyToPathFluent>{

        
    public N and();    public N endKeyToPathObject();
}
    public interface FlexPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,FlexPersistentVolumeSourceFluent>{

        
    public N and();    public N endFlexPersistentVolumeSourceObject();
}
    public interface NamespaceListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamespaceListFluent>{

        
    public N and();    public N endNamespaceListObject();
}
    public interface PodDNSConfigObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodDNSConfigFluent>{

        
    public N and();    public N endPodDNSConfigObject();
}
    public interface NodeListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeListFluent>{

        
    public N and();    public N endNodeListObject();
}
    public interface BindingObjectNested extends io.fabric8.kubernetes.api.builder.Nested,BindingFluent>{

        
    public N and();    public N endBindingObject();
}
    public interface VolumeProjectionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,VolumeProjectionFluent>{

        
    public N and();    public N endVolumeProjectionObject();
}
    public interface EnvVarSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EnvVarSourceFluent>{

        
    public N and();    public N endEnvVarSourceObject();
}
    public interface ResourceQuotaObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ResourceQuotaFluent>{

        
    public N and();    public N endResourceQuotaObject();
}
    public interface SecretObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretFluent>{

        
    public N and();    public N endSecretObject();
}
    public interface ServiceListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceListFluent>{

        
    public N and();    public N endServiceListObject();
}
    public interface VolumeNodeAffinityObjectNested extends io.fabric8.kubernetes.api.builder.Nested,VolumeNodeAffinityFluent>{

        
    public N and();    public N endVolumeNodeAffinityObject();
}
    public interface ResourceQuotaSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ResourceQuotaSpecFluent>{

        
    public N and();    public N endResourceQuotaSpecObject();
}
    public interface NodeSelectorTermObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeSelectorTermFluent>{

        
    public N and();    public N endNodeSelectorTermObject();
}
    public interface ScaleIOPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ScaleIOPersistentVolumeSourceFluent>{

        
    public N and();    public N endScaleIOPersistentVolumeSourceObject();
}
    public interface ListOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ListOptionsFluent>{

        
    public N and();    public N endListOptionsObject();
}
    public interface WeightedPodAffinityTermObjectNested extends io.fabric8.kubernetes.api.builder.Nested,WeightedPodAffinityTermFluent>{

        
    public N and();    public N endWeightedPodAffinityTermObject();
}
    public interface BaseKubernetesListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,BaseKubernetesListFluent>{

        
    public N and();    public N endBaseKubernetesListObject();
}
    public interface NodeSystemInfoObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeSystemInfoFluent>{

        
    public N and();    public N endNodeSystemInfoObject();
}
    public interface TopologySelectorLabelRequirementObjectNested extends io.fabric8.kubernetes.api.builder.Nested,TopologySelectorLabelRequirementFluent>{

        
    public N and();    public N endTopologySelectorLabelRequirementObject();
}
    public interface RBDPersistentVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,RBDPersistentVolumeSourceFluent>{

        
    public N and();    public N endRBDPersistentVolumeSourceObject();
}
    public interface SELinuxOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SELinuxOptionsFluent>{

        
    public N and();    public N endSELinuxOptionsObject();
}
    public interface AuthProviderConfigObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AuthProviderConfigFluent>{

        
    public N and();    public N endAuthProviderConfigObject();
}
    public interface HostAliasObjectNested extends io.fabric8.kubernetes.api.builder.Nested,HostAliasFluent>{

        
    public N and();    public N endHostAliasObject();
}
    public interface NodeDaemonEndpointsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeDaemonEndpointsFluent>{

        
    public N and();    public N endNodeDaemonEndpointsObject();
}
    public interface CSIVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CSIVolumeSourceFluent>{

        
    public N and();    public N endCSIVolumeSourceObject();
}
    public interface VolumeDeviceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,VolumeDeviceFluent>{

        
    public N and();    public N endVolumeDeviceObject();
}
    public interface PersistentVolumeSpecObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeSpecFluent>{

        
    public N and();    public N endPersistentVolumeSpecObject();
}
    public interface NodeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NodeFluent>{

        
    public N and();    public N endNodeObject();
}
    public interface NFSVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NFSVolumeSourceFluent>{

        
    public N and();    public N endNFSVolumeSourceObject();
}
    public interface VolumeObjectNested extends io.fabric8.kubernetes.api.builder.Nested,VolumeFluent>{

        
    public N and();    public N endVolumeObject();
}
    public interface ClusterObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ClusterFluent>{

        
    public N and();    public N endClusterObject();
}
    public interface StorageOSVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,StorageOSVolumeSourceFluent>{

        
    public N and();    public N endStorageOSVolumeSourceObject();
}
    public interface ExecConfigObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ExecConfigFluent>{

        
    public N and();    public N endExecConfigObject();
}
    public interface KubernetesListObjectNested extends io.fabric8.kubernetes.api.builder.Nested,KubernetesListFluent>{

        
    public N and();    public N endKubernetesListObject();
}
    public interface PodStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodStatusFluent>{

        
    public N and();    public N endPodStatusObject();
}
    public interface PersistentVolumeStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PersistentVolumeStatusFluent>{

        
    public N and();    public N endPersistentVolumeStatusObject();
}
    public interface EndpointPortObjectNested extends io.fabric8.kubernetes.api.builder.Nested,EndpointPortFluent>{

        
    public N and();    public N endEndpointPortObject();
}
    public interface CapabilitiesObjectNested extends io.fabric8.kubernetes.api.builder.Nested,CapabilitiesFluent>{

        
    public N and();    public N endCapabilitiesObject();
}
    public interface HTTPHeaderObjectNested extends io.fabric8.kubernetes.api.builder.Nested,HTTPHeaderFluent>{

        
    public N and();    public N endHTTPHeaderObject();
}
    public interface WatchEventObjectNested extends io.fabric8.kubernetes.api.builder.Nested,WatchEventFluent>{

        
    public N and();    public N endWatchEventObject();
}
    public interface ObjectReferenceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ObjectReferenceFluent>{

        
    public N and();    public N endObjectReferenceObject();
}
    public interface LimitRangeItemObjectNested extends io.fabric8.kubernetes.api.builder.Nested,LimitRangeItemFluent>{

        
    public N and();    public N endLimitRangeItemObject();
}
    public interface SecretProjectionObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretProjectionFluent>{

        
    public N and();    public N endSecretProjectionObject();
}
    public interface GetOptionsObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GetOptionsFluent>{

        
    public N and();    public N endGetOptionsObject();
}
    public interface GlusterfsVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,GlusterfsVolumeSourceFluent>{

        
    public N and();    public N endGlusterfsVolumeSourceObject();
}
    public interface ManagedFieldsEntryObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ManagedFieldsEntryFluent>{

        
    public N and();    public N endManagedFieldsEntryObject();
}
    public interface NamespaceStatusObjectNested extends io.fabric8.kubernetes.api.builder.Nested,NamespaceStatusFluent>{

        
    public N and();    public N endNamespaceStatusObject();
}
    public interface SecretEnvSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,SecretEnvSourceFluent>{

        
    public N and();    public N endSecretEnvSourceObject();
}
    public interface AWSElasticBlockStoreVolumeSourceObjectNested extends io.fabric8.kubernetes.api.builder.Nested,AWSElasticBlockStoreVolumeSourceFluent>{

        
    public N and();    public N endAWSElasticBlockStoreVolumeSourceObject();
}
    public interface ServiceAccountObjectNested extends io.fabric8.kubernetes.api.builder.Nested,ServiceAccountFluent>{

        
    public N and();    public N endServiceAccountObject();
}
    public interface PodIPObjectNested extends io.fabric8.kubernetes.api.builder.Nested,PodIPFluent>{

        
    public N and();    public N endPodIPObject();
}


}