ValidationSchemaFluent (Fabric8 :: Kubernetes Model

java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.kubernetes.api.model.ValidationSchemaFluent<A>

All Implemented Interfaces:

Fluent<A>, Visitable<A>

Direct Known Subclasses:

ValidationSchemaBuilder
```
public class ValidationSchemaFluent<A extends ValidationSchemaFluent<A>>
extends BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`ValidationSchemaFluent.APIGroupListNested<N>`
`class`	`ValidationSchemaFluent.APIGroupNested<N>`
`class`	`ValidationSchemaFluent.APIResourceListNested<N>`
`class`	`ValidationSchemaFluent.APIResourceNested<N>`
`class`	`ValidationSchemaFluent.APIServiceListNested<N>`
`class`	`ValidationSchemaFluent.APIServiceNested<N>`
`class`	`ValidationSchemaFluent.BindingNested<N>`
`class`	`ValidationSchemaFluent.ComponentStatusListNested<N>`
`class`	`ValidationSchemaFluent.ComponentStatusNested<N>`
`class`	`ValidationSchemaFluent.ConditionNested<N>`
`class`	`ValidationSchemaFluent.ConfigMapListNested<N>`
`class`	`ValidationSchemaFluent.ConfigMapNested<N>`
`class`	`ValidationSchemaFluent.ConfigNested<N>`
`class`	`ValidationSchemaFluent.ContainerStatusNested<N>`
`class`	`ValidationSchemaFluent.CreateOptionsNested<N>`
`class`	`ValidationSchemaFluent.DeleteOptionsNested<N>`
`class`	`ValidationSchemaFluent.EndpointPortNested<N>`
`class`	`ValidationSchemaFluent.EndpointsListNested<N>`
`class`	`ValidationSchemaFluent.EndpointsNested<N>`
`class`	`ValidationSchemaFluent.EnvVarNested<N>`
`class`	`ValidationSchemaFluent.EventListNested<N>`
`class`	`ValidationSchemaFluent.EventNested<N>`
`class`	`ValidationSchemaFluent.EventSeriesNested<N>`
`class`	`ValidationSchemaFluent.EventSourceNested<N>`
`class`	`ValidationSchemaFluent.GetOptionsNested<N>`
`class`	`ValidationSchemaFluent.GroupKindNested<N>`
`class`	`ValidationSchemaFluent.GroupVersionKindNested<N>`
`class`	`ValidationSchemaFluent.GroupVersionResourceNested<N>`
`class`	`ValidationSchemaFluent.InfoNested<N>`
`class`	`ValidationSchemaFluent.KubernetesListNested<N>`
`class`	`ValidationSchemaFluent.LimitRangeListNested<N>`
`class`	`ValidationSchemaFluent.ListOptionsNested<N>`
`class`	`ValidationSchemaFluent.MicroTimeNested<N>`
`class`	`ValidationSchemaFluent.NamespaceListNested<N>`
`class`	`ValidationSchemaFluent.NamespaceNested<N>`
`class`	`ValidationSchemaFluent.NodeListNested<N>`
`class`	`ValidationSchemaFluent.NodeNested<N>`
`class`	`ValidationSchemaFluent.ObjectMetaNested<N>`
`class`	`ValidationSchemaFluent.PatchNested<N>`
`class`	`ValidationSchemaFluent.PatchOptionsNested<N>`
`class`	`ValidationSchemaFluent.PersistentVolumeClaimListNested<N>`
`class`	`ValidationSchemaFluent.PersistentVolumeClaimNested<N>`
`class`	`ValidationSchemaFluent.PersistentVolumeListNested<N>`
`class`	`ValidationSchemaFluent.PersistentVolumeNested<N>`
`class`	`ValidationSchemaFluent.PodExecOptionsNested<N>`
`class`	`ValidationSchemaFluent.PodListNested<N>`
`class`	`ValidationSchemaFluent.PodTemplateListNested<N>`
`class`	`ValidationSchemaFluent.QuantityNested<N>`
`class`	`ValidationSchemaFluent.ReplicationControllerListNested<N>`
`class`	`ValidationSchemaFluent.ResourceQuotaListNested<N>`
`class`	`ValidationSchemaFluent.ResourceQuotaNested<N>`
`class`	`ValidationSchemaFluent.RootPathsNested<N>`
`class`	`ValidationSchemaFluent.SecretListNested<N>`
`class`	`ValidationSchemaFluent.SecretNested<N>`
`class`	`ValidationSchemaFluent.ServiceAccountListNested<N>`
`class`	`ValidationSchemaFluent.ServiceAccountNested<N>`
`class`	`ValidationSchemaFluent.ServiceListNested<N>`
`class`	`ValidationSchemaFluent.StatusNested<N>`
`class`	`ValidationSchemaFluent.TolerationNested<N>`
`class`	`ValidationSchemaFluent.TopologySelectorTermNested<N>`
`class`	`ValidationSchemaFluent.TypeMetaNested<N>`
`class`	`ValidationSchemaFluent.UpdateOptionsNested<N>`
`class`	`ValidationSchemaFluent.WatchEventNested<N>`

Field Summary
- Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
  _visitables, VISIT

Constructor Summary

Constructors
Constructor and Description

ValidationSchemaFluent()

ValidationSchemaFluent(ValidationSchema instance)

Constructors
Constructor and Description
`ValidationSchemaFluent()`
`ValidationSchemaFluent(ValidationSchema instance)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToAdditionalProperties(String key, Object value)`
`APIGroup`	`buildAPIGroup()`
`APIGroupList`	`buildAPIGroupList()`
`APIResource`	`buildAPIResource()`
`APIResourceList`	`buildAPIResourceList()`
`APIService`	`buildAPIService()`
`APIServiceList`	`buildAPIServiceList()`
`Binding`	`buildBinding()`
`ComponentStatus`	`buildComponentStatus()`
`ComponentStatusList`	`buildComponentStatusList()`
`Condition`	`buildCondition()`
`Config`	`buildConfig()`
`ConfigMap`	`buildConfigMap()`
`ConfigMapList`	`buildConfigMapList()`
`ContainerStatus`	`buildContainerStatus()`
`CreateOptions`	`buildCreateOptions()`
`DeleteOptions`	`buildDeleteOptions()`
`EndpointPort`	`buildEndpointPort()`
`Endpoints`	`buildEndpoints()`
`EndpointsList`	`buildEndpointsList()`
`EnvVar`	`buildEnvVar()`
`Event`	`buildEvent()`
`EventList`	`buildEventList()`
`EventSeries`	`buildEventSeries()`
`EventSource`	`buildEventSource()`
`GetOptions`	`buildGetOptions()`
`GroupKind`	`buildGroupKind()`
`GroupVersionKind`	`buildGroupVersionKind()`
`GroupVersionResource`	`buildGroupVersionResource()`
`Info`	`buildInfo()`
`KubernetesList`	`buildKubernetesList()`
`LimitRangeList`	`buildLimitRangeList()`
`ListOptions`	`buildListOptions()`
`MicroTime`	`buildMicroTime()`
`Namespace`	`buildNamespace()`
`NamespaceList`	`buildNamespaceList()`
`Node`	`buildNode()`
`NodeList`	`buildNodeList()`
`ObjectMeta`	`buildObjectMeta()`
`Patch`	`buildPatch()`
`PatchOptions`	`buildPatchOptions()`
`PersistentVolume`	`buildPersistentVolume()`
`PersistentVolumeClaim`	`buildPersistentVolumeClaim()`
`PersistentVolumeClaimList`	`buildPersistentVolumeClaimList()`
`PersistentVolumeList`	`buildPersistentVolumeList()`
`PodExecOptions`	`buildPodExecOptions()`
`PodList`	`buildPodList()`
`PodTemplateList`	`buildPodTemplateList()`
`Quantity`	`buildQuantity()`
`ReplicationControllerList`	`buildReplicationControllerList()`
`ResourceQuota`	`buildResourceQuota()`
`ResourceQuotaList`	`buildResourceQuotaList()`
`RootPaths`	`buildRootPaths()`
`Secret`	`buildSecret()`
`SecretList`	`buildSecretList()`
`ServiceAccount`	`buildServiceAccount()`
`ServiceAccountList`	`buildServiceAccountList()`
`ServiceList`	`buildServiceList()`
`Status`	`buildStatus()`
`Toleration`	`buildToleration()`
`TopologySelectorTerm`	`buildTopologySelectorTerm()`
`TypeMeta`	`buildTypeMeta()`
`UpdateOptions`	`buildUpdateOptions()`
`WatchEvent`	`buildWatchEvent()`
`ValidationSchemaFluent.APIGroupNested<A>`	`editAPIGroup()`
`ValidationSchemaFluent.APIGroupListNested<A>`	`editAPIGroupList()`
`ValidationSchemaFluent.APIResourceNested<A>`	`editAPIResource()`
`ValidationSchemaFluent.APIResourceListNested<A>`	`editAPIResourceList()`
`ValidationSchemaFluent.APIServiceNested<A>`	`editAPIService()`
`ValidationSchemaFluent.APIServiceListNested<A>`	`editAPIServiceList()`
`ValidationSchemaFluent.BindingNested<A>`	`editBinding()`
`ValidationSchemaFluent.ComponentStatusNested<A>`	`editComponentStatus()`
`ValidationSchemaFluent.ComponentStatusListNested<A>`	`editComponentStatusList()`
`ValidationSchemaFluent.ConditionNested<A>`	`editCondition()`
`ValidationSchemaFluent.ConfigNested<A>`	`editConfig()`
`ValidationSchemaFluent.ConfigMapNested<A>`	`editConfigMap()`
`ValidationSchemaFluent.ConfigMapListNested<A>`	`editConfigMapList()`
`ValidationSchemaFluent.ContainerStatusNested<A>`	`editContainerStatus()`
`ValidationSchemaFluent.CreateOptionsNested<A>`	`editCreateOptions()`
`ValidationSchemaFluent.DeleteOptionsNested<A>`	`editDeleteOptions()`
`ValidationSchemaFluent.EndpointPortNested<A>`	`editEndpointPort()`
`ValidationSchemaFluent.EndpointsNested<A>`	`editEndpoints()`
`ValidationSchemaFluent.EndpointsListNested<A>`	`editEndpointsList()`
`ValidationSchemaFluent.EnvVarNested<A>`	`editEnvVar()`
`ValidationSchemaFluent.EventNested<A>`	`editEvent()`
`ValidationSchemaFluent.EventListNested<A>`	`editEventList()`
`ValidationSchemaFluent.EventSeriesNested<A>`	`editEventSeries()`
`ValidationSchemaFluent.EventSourceNested<A>`	`editEventSource()`
`ValidationSchemaFluent.GetOptionsNested<A>`	`editGetOptions()`
`ValidationSchemaFluent.GroupKindNested<A>`	`editGroupKind()`
`ValidationSchemaFluent.GroupVersionKindNested<A>`	`editGroupVersionKind()`
`ValidationSchemaFluent.GroupVersionResourceNested<A>`	`editGroupVersionResource()`
`ValidationSchemaFluent.InfoNested<A>`	`editInfo()`
`ValidationSchemaFluent.KubernetesListNested<A>`	`editKubernetesList()`
`ValidationSchemaFluent.LimitRangeListNested<A>`	`editLimitRangeList()`
`ValidationSchemaFluent.ListOptionsNested<A>`	`editListOptions()`
`ValidationSchemaFluent.MicroTimeNested<A>`	`editMicroTime()`
`ValidationSchemaFluent.NamespaceNested<A>`	`editNamespace()`
`ValidationSchemaFluent.NamespaceListNested<A>`	`editNamespaceList()`
`ValidationSchemaFluent.NodeNested<A>`	`editNode()`
`ValidationSchemaFluent.NodeListNested<A>`	`editNodeList()`
`ValidationSchemaFluent.ObjectMetaNested<A>`	`editObjectMeta()`
`ValidationSchemaFluent.APIGroupNested<A>`	`editOrNewAPIGroup()`
`ValidationSchemaFluent.APIGroupNested<A>`	`editOrNewAPIGroupLike(APIGroup item)`
`ValidationSchemaFluent.APIGroupListNested<A>`	`editOrNewAPIGroupList()`
`ValidationSchemaFluent.APIGroupListNested<A>`	`editOrNewAPIGroupListLike(APIGroupList item)`
`ValidationSchemaFluent.APIResourceNested<A>`	`editOrNewAPIResource()`
`ValidationSchemaFluent.APIResourceNested<A>`	`editOrNewAPIResourceLike(APIResource item)`
`ValidationSchemaFluent.APIResourceListNested<A>`	`editOrNewAPIResourceList()`
`ValidationSchemaFluent.APIResourceListNested<A>`	`editOrNewAPIResourceListLike(APIResourceList item)`
`ValidationSchemaFluent.APIServiceNested<A>`	`editOrNewAPIService()`
`ValidationSchemaFluent.APIServiceNested<A>`	`editOrNewAPIServiceLike(APIService item)`
`ValidationSchemaFluent.APIServiceListNested<A>`	`editOrNewAPIServiceList()`
`ValidationSchemaFluent.APIServiceListNested<A>`	`editOrNewAPIServiceListLike(APIServiceList item)`
`ValidationSchemaFluent.BindingNested<A>`	`editOrNewBinding()`
`ValidationSchemaFluent.BindingNested<A>`	`editOrNewBindingLike(Binding item)`
`ValidationSchemaFluent.ComponentStatusNested<A>`	`editOrNewComponentStatus()`
`ValidationSchemaFluent.ComponentStatusNested<A>`	`editOrNewComponentStatusLike(ComponentStatus item)`
`ValidationSchemaFluent.ComponentStatusListNested<A>`	`editOrNewComponentStatusList()`
`ValidationSchemaFluent.ComponentStatusListNested<A>`	`editOrNewComponentStatusListLike(ComponentStatusList item)`
`ValidationSchemaFluent.ConditionNested<A>`	`editOrNewCondition()`
`ValidationSchemaFluent.ConditionNested<A>`	`editOrNewConditionLike(Condition item)`
`ValidationSchemaFluent.ConfigNested<A>`	`editOrNewConfig()`
`ValidationSchemaFluent.ConfigNested<A>`	`editOrNewConfigLike(Config item)`
`ValidationSchemaFluent.ConfigMapNested<A>`	`editOrNewConfigMap()`
`ValidationSchemaFluent.ConfigMapNested<A>`	`editOrNewConfigMapLike(ConfigMap item)`
`ValidationSchemaFluent.ConfigMapListNested<A>`	`editOrNewConfigMapList()`
`ValidationSchemaFluent.ConfigMapListNested<A>`	`editOrNewConfigMapListLike(ConfigMapList item)`
`ValidationSchemaFluent.ContainerStatusNested<A>`	`editOrNewContainerStatus()`
`ValidationSchemaFluent.ContainerStatusNested<A>`	`editOrNewContainerStatusLike(ContainerStatus item)`
`ValidationSchemaFluent.CreateOptionsNested<A>`	`editOrNewCreateOptions()`
`ValidationSchemaFluent.CreateOptionsNested<A>`	`editOrNewCreateOptionsLike(CreateOptions item)`
`ValidationSchemaFluent.DeleteOptionsNested<A>`	`editOrNewDeleteOptions()`
`ValidationSchemaFluent.DeleteOptionsNested<A>`	`editOrNewDeleteOptionsLike(DeleteOptions item)`
`ValidationSchemaFluent.EndpointPortNested<A>`	`editOrNewEndpointPort()`
`ValidationSchemaFluent.EndpointPortNested<A>`	`editOrNewEndpointPortLike(EndpointPort item)`
`ValidationSchemaFluent.EndpointsNested<A>`	`editOrNewEndpoints()`
`ValidationSchemaFluent.EndpointsNested<A>`	`editOrNewEndpointsLike(Endpoints item)`
`ValidationSchemaFluent.EndpointsListNested<A>`	`editOrNewEndpointsList()`
`ValidationSchemaFluent.EndpointsListNested<A>`	`editOrNewEndpointsListLike(EndpointsList item)`
`ValidationSchemaFluent.EnvVarNested<A>`	`editOrNewEnvVar()`
`ValidationSchemaFluent.EnvVarNested<A>`	`editOrNewEnvVarLike(EnvVar item)`
`ValidationSchemaFluent.EventNested<A>`	`editOrNewEvent()`
`ValidationSchemaFluent.EventNested<A>`	`editOrNewEventLike(Event item)`
`ValidationSchemaFluent.EventListNested<A>`	`editOrNewEventList()`
`ValidationSchemaFluent.EventListNested<A>`	`editOrNewEventListLike(EventList item)`
`ValidationSchemaFluent.EventSeriesNested<A>`	`editOrNewEventSeries()`
`ValidationSchemaFluent.EventSeriesNested<A>`	`editOrNewEventSeriesLike(EventSeries item)`
`ValidationSchemaFluent.EventSourceNested<A>`	`editOrNewEventSource()`
`ValidationSchemaFluent.EventSourceNested<A>`	`editOrNewEventSourceLike(EventSource item)`
`ValidationSchemaFluent.GetOptionsNested<A>`	`editOrNewGetOptions()`
`ValidationSchemaFluent.GetOptionsNested<A>`	`editOrNewGetOptionsLike(GetOptions item)`
`ValidationSchemaFluent.GroupKindNested<A>`	`editOrNewGroupKind()`
`ValidationSchemaFluent.GroupKindNested<A>`	`editOrNewGroupKindLike(GroupKind item)`
`ValidationSchemaFluent.GroupVersionKindNested<A>`	`editOrNewGroupVersionKind()`
`ValidationSchemaFluent.GroupVersionKindNested<A>`	`editOrNewGroupVersionKindLike(GroupVersionKind item)`
`ValidationSchemaFluent.GroupVersionResourceNested<A>`	`editOrNewGroupVersionResource()`
`ValidationSchemaFluent.GroupVersionResourceNested<A>`	`editOrNewGroupVersionResourceLike(GroupVersionResource item)`
`ValidationSchemaFluent.InfoNested<A>`	`editOrNewInfo()`
`ValidationSchemaFluent.InfoNested<A>`	`editOrNewInfoLike(Info item)`
`ValidationSchemaFluent.KubernetesListNested<A>`	`editOrNewKubernetesList()`
`ValidationSchemaFluent.KubernetesListNested<A>`	`editOrNewKubernetesListLike(KubernetesList item)`
`ValidationSchemaFluent.LimitRangeListNested<A>`	`editOrNewLimitRangeList()`
`ValidationSchemaFluent.LimitRangeListNested<A>`	`editOrNewLimitRangeListLike(LimitRangeList item)`
`ValidationSchemaFluent.ListOptionsNested<A>`	`editOrNewListOptions()`
`ValidationSchemaFluent.ListOptionsNested<A>`	`editOrNewListOptionsLike(ListOptions item)`
`ValidationSchemaFluent.MicroTimeNested<A>`	`editOrNewMicroTime()`
`ValidationSchemaFluent.MicroTimeNested<A>`	`editOrNewMicroTimeLike(MicroTime item)`
`ValidationSchemaFluent.NamespaceNested<A>`	`editOrNewNamespace()`
`ValidationSchemaFluent.NamespaceNested<A>`	`editOrNewNamespaceLike(Namespace item)`
`ValidationSchemaFluent.NamespaceListNested<A>`	`editOrNewNamespaceList()`
`ValidationSchemaFluent.NamespaceListNested<A>`	`editOrNewNamespaceListLike(NamespaceList item)`
`ValidationSchemaFluent.NodeNested<A>`	`editOrNewNode()`
`ValidationSchemaFluent.NodeNested<A>`	`editOrNewNodeLike(Node item)`
`ValidationSchemaFluent.NodeListNested<A>`	`editOrNewNodeList()`
`ValidationSchemaFluent.NodeListNested<A>`	`editOrNewNodeListLike(NodeList item)`
`ValidationSchemaFluent.ObjectMetaNested<A>`	`editOrNewObjectMeta()`
`ValidationSchemaFluent.ObjectMetaNested<A>`	`editOrNewObjectMetaLike(ObjectMeta item)`
`ValidationSchemaFluent.PatchNested<A>`	`editOrNewPatch()`
`ValidationSchemaFluent.PatchNested<A>`	`editOrNewPatchLike(Patch item)`
`ValidationSchemaFluent.PatchOptionsNested<A>`	`editOrNewPatchOptions()`
`ValidationSchemaFluent.PatchOptionsNested<A>`	`editOrNewPatchOptionsLike(PatchOptions item)`
`ValidationSchemaFluent.PersistentVolumeNested<A>`	`editOrNewPersistentVolume()`
`ValidationSchemaFluent.PersistentVolumeClaimNested<A>`	`editOrNewPersistentVolumeClaim()`
`ValidationSchemaFluent.PersistentVolumeClaimNested<A>`	`editOrNewPersistentVolumeClaimLike(PersistentVolumeClaim item)`
`ValidationSchemaFluent.PersistentVolumeClaimListNested<A>`	`editOrNewPersistentVolumeClaimList()`
`ValidationSchemaFluent.PersistentVolumeClaimListNested<A>`	`editOrNewPersistentVolumeClaimListLike(PersistentVolumeClaimList item)`
`ValidationSchemaFluent.PersistentVolumeNested<A>`	`editOrNewPersistentVolumeLike(PersistentVolume item)`
`ValidationSchemaFluent.PersistentVolumeListNested<A>`	`editOrNewPersistentVolumeList()`
`ValidationSchemaFluent.PersistentVolumeListNested<A>`	`editOrNewPersistentVolumeListLike(PersistentVolumeList item)`
`ValidationSchemaFluent.PodExecOptionsNested<A>`	`editOrNewPodExecOptions()`
`ValidationSchemaFluent.PodExecOptionsNested<A>`	`editOrNewPodExecOptionsLike(PodExecOptions item)`
`ValidationSchemaFluent.PodListNested<A>`	`editOrNewPodList()`
`ValidationSchemaFluent.PodListNested<A>`	`editOrNewPodListLike(PodList item)`
`ValidationSchemaFluent.PodTemplateListNested<A>`	`editOrNewPodTemplateList()`
`ValidationSchemaFluent.PodTemplateListNested<A>`	`editOrNewPodTemplateListLike(PodTemplateList item)`
`ValidationSchemaFluent.QuantityNested<A>`	`editOrNewQuantity()`
`ValidationSchemaFluent.QuantityNested<A>`	`editOrNewQuantityLike(Quantity item)`
`ValidationSchemaFluent.ReplicationControllerListNested<A>`	`editOrNewReplicationControllerList()`
`ValidationSchemaFluent.ReplicationControllerListNested<A>`	`editOrNewReplicationControllerListLike(ReplicationControllerList item)`
`ValidationSchemaFluent.ResourceQuotaNested<A>`	`editOrNewResourceQuota()`
`ValidationSchemaFluent.ResourceQuotaNested<A>`	`editOrNewResourceQuotaLike(ResourceQuota item)`
`ValidationSchemaFluent.ResourceQuotaListNested<A>`	`editOrNewResourceQuotaList()`
`ValidationSchemaFluent.ResourceQuotaListNested<A>`	`editOrNewResourceQuotaListLike(ResourceQuotaList item)`
`ValidationSchemaFluent.RootPathsNested<A>`	`editOrNewRootPaths()`
`ValidationSchemaFluent.RootPathsNested<A>`	`editOrNewRootPathsLike(RootPaths item)`
`ValidationSchemaFluent.SecretNested<A>`	`editOrNewSecret()`
`ValidationSchemaFluent.SecretNested<A>`	`editOrNewSecretLike(Secret item)`
`ValidationSchemaFluent.SecretListNested<A>`	`editOrNewSecretList()`
`ValidationSchemaFluent.SecretListNested<A>`	`editOrNewSecretListLike(SecretList item)`
`ValidationSchemaFluent.ServiceAccountNested<A>`	`editOrNewServiceAccount()`
`ValidationSchemaFluent.ServiceAccountNested<A>`	`editOrNewServiceAccountLike(ServiceAccount item)`
`ValidationSchemaFluent.ServiceAccountListNested<A>`	`editOrNewServiceAccountList()`
`ValidationSchemaFluent.ServiceAccountListNested<A>`	`editOrNewServiceAccountListLike(ServiceAccountList item)`
`ValidationSchemaFluent.ServiceListNested<A>`	`editOrNewServiceList()`
`ValidationSchemaFluent.ServiceListNested<A>`	`editOrNewServiceListLike(ServiceList item)`
`ValidationSchemaFluent.StatusNested<A>`	`editOrNewStatus()`
`ValidationSchemaFluent.StatusNested<A>`	`editOrNewStatusLike(Status item)`
`ValidationSchemaFluent.TolerationNested<A>`	`editOrNewToleration()`
`ValidationSchemaFluent.TolerationNested<A>`	`editOrNewTolerationLike(Toleration item)`
`ValidationSchemaFluent.TopologySelectorTermNested<A>`	`editOrNewTopologySelectorTerm()`
`ValidationSchemaFluent.TopologySelectorTermNested<A>`	`editOrNewTopologySelectorTermLike(TopologySelectorTerm item)`
`ValidationSchemaFluent.TypeMetaNested<A>`	`editOrNewTypeMeta()`
`ValidationSchemaFluent.TypeMetaNested<A>`	`editOrNewTypeMetaLike(TypeMeta item)`
`ValidationSchemaFluent.UpdateOptionsNested<A>`	`editOrNewUpdateOptions()`
`ValidationSchemaFluent.UpdateOptionsNested<A>`	`editOrNewUpdateOptionsLike(UpdateOptions item)`
`ValidationSchemaFluent.WatchEventNested<A>`	`editOrNewWatchEvent()`
`ValidationSchemaFluent.WatchEventNested<A>`	`editOrNewWatchEventLike(WatchEvent item)`
`ValidationSchemaFluent.PatchNested<A>`	`editPatch()`
`ValidationSchemaFluent.PatchOptionsNested<A>`	`editPatchOptions()`
`ValidationSchemaFluent.PersistentVolumeNested<A>`	`editPersistentVolume()`
`ValidationSchemaFluent.PersistentVolumeClaimNested<A>`	`editPersistentVolumeClaim()`
`ValidationSchemaFluent.PersistentVolumeClaimListNested<A>`	`editPersistentVolumeClaimList()`
`ValidationSchemaFluent.PersistentVolumeListNested<A>`	`editPersistentVolumeList()`
`ValidationSchemaFluent.PodExecOptionsNested<A>`	`editPodExecOptions()`
`ValidationSchemaFluent.PodListNested<A>`	`editPodList()`
`ValidationSchemaFluent.PodTemplateListNested<A>`	`editPodTemplateList()`
`ValidationSchemaFluent.QuantityNested<A>`	`editQuantity()`
`ValidationSchemaFluent.ReplicationControllerListNested<A>`	`editReplicationControllerList()`
`ValidationSchemaFluent.ResourceQuotaNested<A>`	`editResourceQuota()`
`ValidationSchemaFluent.ResourceQuotaListNested<A>`	`editResourceQuotaList()`
`ValidationSchemaFluent.RootPathsNested<A>`	`editRootPaths()`
`ValidationSchemaFluent.SecretNested<A>`	`editSecret()`
`ValidationSchemaFluent.SecretListNested<A>`	`editSecretList()`
`ValidationSchemaFluent.ServiceAccountNested<A>`	`editServiceAccount()`
`ValidationSchemaFluent.ServiceAccountListNested<A>`	`editServiceAccountList()`
`ValidationSchemaFluent.ServiceListNested<A>`	`editServiceList()`
`ValidationSchemaFluent.StatusNested<A>`	`editStatus()`
`ValidationSchemaFluent.TolerationNested<A>`	`editToleration()`
`ValidationSchemaFluent.TopologySelectorTermNested<A>`	`editTopologySelectorTerm()`
`ValidationSchemaFluent.TypeMetaNested<A>`	`editTypeMeta()`
`ValidationSchemaFluent.UpdateOptionsNested<A>`	`editUpdateOptions()`
`ValidationSchemaFluent.WatchEventNested<A>`	`editWatchEvent()`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getTime()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasAPIGroup()`
`boolean`	`hasAPIGroupList()`
`boolean`	`hasAPIResource()`
`boolean`	`hasAPIResourceList()`
`boolean`	`hasAPIService()`
`boolean`	`hasAPIServiceList()`
`boolean`	`hasBinding()`
`boolean`	`hasComponentStatus()`
`boolean`	`hasComponentStatusList()`
`boolean`	`hasCondition()`
`boolean`	`hasConfig()`
`boolean`	`hasConfigMap()`
`boolean`	`hasConfigMapList()`
`boolean`	`hasContainerStatus()`
`boolean`	`hasCreateOptions()`
`boolean`	`hasDeleteOptions()`
`boolean`	`hasEndpointPort()`
`boolean`	`hasEndpoints()`
`boolean`	`hasEndpointsList()`
`boolean`	`hasEnvVar()`
`boolean`	`hasEvent()`
`boolean`	`hasEventList()`
`boolean`	`hasEventSeries()`
`boolean`	`hasEventSource()`
`boolean`	`hasGetOptions()`
`boolean`	`hasGroupKind()`
`boolean`	`hasGroupVersionKind()`
`boolean`	`hasGroupVersionResource()`
`int`	`hashCode()`
`boolean`	`hasInfo()`
`boolean`	`hasKubernetesList()`
`boolean`	`hasLimitRangeList()`
`boolean`	`hasListOptions()`
`boolean`	`hasMicroTime()`
`boolean`	`hasNamespace()`
`boolean`	`hasNamespaceList()`
`boolean`	`hasNode()`
`boolean`	`hasNodeList()`
`boolean`	`hasObjectMeta()`
`boolean`	`hasPatch()`
`boolean`	`hasPatchOptions()`
`boolean`	`hasPersistentVolume()`
`boolean`	`hasPersistentVolumeClaim()`
`boolean`	`hasPersistentVolumeClaimList()`
`boolean`	`hasPersistentVolumeList()`
`boolean`	`hasPodExecOptions()`
`boolean`	`hasPodList()`
`boolean`	`hasPodTemplateList()`
`boolean`	`hasQuantity()`
`boolean`	`hasReplicationControllerList()`
`boolean`	`hasResourceQuota()`
`boolean`	`hasResourceQuotaList()`
`boolean`	`hasRootPaths()`
`boolean`	`hasSecret()`
`boolean`	`hasSecretList()`
`boolean`	`hasServiceAccount()`
`boolean`	`hasServiceAccountList()`
`boolean`	`hasServiceList()`
`boolean`	`hasStatus()`
`boolean`	`hasTime()`
`boolean`	`hasToleration()`
`boolean`	`hasTopologySelectorTerm()`
`boolean`	`hasTypeMeta()`
`boolean`	`hasUpdateOptions()`
`boolean`	`hasWatchEvent()`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromAdditionalProperties(String key)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withAPIGroup(APIGroup aPIGroup)`
`A`	`withAPIGroupList(APIGroupList aPIGroupList)`
`A`	`withAPIResource(APIResource aPIResource)`
`A`	`withAPIResourceList(APIResourceList aPIResourceList)`
`A`	`withAPIService(APIService aPIService)`
`A`	`withAPIServiceList(APIServiceList aPIServiceList)`
`A`	`withBinding(Binding binding)`
`A`	`withComponentStatus(ComponentStatus componentStatus)`
`A`	`withComponentStatusList(ComponentStatusList componentStatusList)`
`A`	`withCondition(Condition condition)`
`A`	`withConfig(Config config)`
`A`	`withConfigMap(ConfigMap configMap)`
`A`	`withConfigMapList(ConfigMapList configMapList)`
`A`	`withContainerStatus(ContainerStatus containerStatus)`
`A`	`withCreateOptions(CreateOptions createOptions)`
`A`	`withDeleteOptions(DeleteOptions deleteOptions)`
`A`	`withEndpointPort(EndpointPort endpointPort)`
`A`	`withEndpoints(Endpoints endpoints)`
`A`	`withEndpointsList(EndpointsList endpointsList)`
`A`	`withEnvVar(EnvVar envVar)`
`A`	`withEvent(Event event)`
`A`	`withEventList(EventList eventList)`
`A`	`withEventSeries(EventSeries eventSeries)`
`A`	`withEventSource(EventSource eventSource)`
`A`	`withGetOptions(GetOptions getOptions)`
`A`	`withGroupKind(GroupKind groupKind)`
`A`	`withGroupVersionKind(GroupVersionKind groupVersionKind)`
`A`	`withGroupVersionResource(GroupVersionResource groupVersionResource)`
`A`	`withInfo(Info info)`
`A`	`withKubernetesList(KubernetesList kubernetesList)`
`A`	`withLimitRangeList(LimitRangeList limitRangeList)`
`A`	`withListOptions(ListOptions listOptions)`
`A`	`withMicroTime(MicroTime microTime)`
`A`	`withNamespace(Namespace namespace)`
`A`	`withNamespaceList(NamespaceList namespaceList)`
`ValidationSchemaFluent.APIGroupNested<A>`	`withNewAPIGroup()`
`ValidationSchemaFluent.APIGroupNested<A>`	`withNewAPIGroupLike(APIGroup item)`
`ValidationSchemaFluent.APIGroupListNested<A>`	`withNewAPIGroupList()`
`ValidationSchemaFluent.APIGroupListNested<A>`	`withNewAPIGroupListLike(APIGroupList item)`
`ValidationSchemaFluent.APIResourceNested<A>`	`withNewAPIResource()`
`ValidationSchemaFluent.APIResourceNested<A>`	`withNewAPIResourceLike(APIResource item)`
`ValidationSchemaFluent.APIResourceListNested<A>`	`withNewAPIResourceList()`
`ValidationSchemaFluent.APIResourceListNested<A>`	`withNewAPIResourceListLike(APIResourceList item)`
`ValidationSchemaFluent.APIServiceNested<A>`	`withNewAPIService()`
`ValidationSchemaFluent.APIServiceNested<A>`	`withNewAPIServiceLike(APIService item)`
`ValidationSchemaFluent.APIServiceListNested<A>`	`withNewAPIServiceList()`
`ValidationSchemaFluent.APIServiceListNested<A>`	`withNewAPIServiceListLike(APIServiceList item)`
`ValidationSchemaFluent.BindingNested<A>`	`withNewBinding()`
`ValidationSchemaFluent.BindingNested<A>`	`withNewBindingLike(Binding item)`
`ValidationSchemaFluent.ComponentStatusNested<A>`	`withNewComponentStatus()`
`ValidationSchemaFluent.ComponentStatusNested<A>`	`withNewComponentStatusLike(ComponentStatus item)`
`ValidationSchemaFluent.ComponentStatusListNested<A>`	`withNewComponentStatusList()`
`ValidationSchemaFluent.ComponentStatusListNested<A>`	`withNewComponentStatusListLike(ComponentStatusList item)`
`ValidationSchemaFluent.ConditionNested<A>`	`withNewCondition()`
`ValidationSchemaFluent.ConditionNested<A>`	`withNewConditionLike(Condition item)`
`ValidationSchemaFluent.ConfigNested<A>`	`withNewConfig()`
`ValidationSchemaFluent.ConfigNested<A>`	`withNewConfigLike(Config item)`
`ValidationSchemaFluent.ConfigMapNested<A>`	`withNewConfigMap()`
`ValidationSchemaFluent.ConfigMapNested<A>`	`withNewConfigMapLike(ConfigMap item)`
`ValidationSchemaFluent.ConfigMapListNested<A>`	`withNewConfigMapList()`
`ValidationSchemaFluent.ConfigMapListNested<A>`	`withNewConfigMapListLike(ConfigMapList item)`
`ValidationSchemaFluent.ContainerStatusNested<A>`	`withNewContainerStatus()`
`ValidationSchemaFluent.ContainerStatusNested<A>`	`withNewContainerStatusLike(ContainerStatus item)`
`ValidationSchemaFluent.CreateOptionsNested<A>`	`withNewCreateOptions()`
`ValidationSchemaFluent.CreateOptionsNested<A>`	`withNewCreateOptionsLike(CreateOptions item)`
`ValidationSchemaFluent.DeleteOptionsNested<A>`	`withNewDeleteOptions()`
`ValidationSchemaFluent.DeleteOptionsNested<A>`	`withNewDeleteOptionsLike(DeleteOptions item)`
`ValidationSchemaFluent.EndpointPortNested<A>`	`withNewEndpointPort()`
`A`	`withNewEndpointPort(String appProtocol, String name, Integer port, String protocol)`
`ValidationSchemaFluent.EndpointPortNested<A>`	`withNewEndpointPortLike(EndpointPort item)`
`ValidationSchemaFluent.EndpointsNested<A>`	`withNewEndpoints()`
`ValidationSchemaFluent.EndpointsNested<A>`	`withNewEndpointsLike(Endpoints item)`
`ValidationSchemaFluent.EndpointsListNested<A>`	`withNewEndpointsList()`
`ValidationSchemaFluent.EndpointsListNested<A>`	`withNewEndpointsListLike(EndpointsList item)`
`ValidationSchemaFluent.EnvVarNested<A>`	`withNewEnvVar()`
`ValidationSchemaFluent.EnvVarNested<A>`	`withNewEnvVarLike(EnvVar item)`
`ValidationSchemaFluent.EventNested<A>`	`withNewEvent()`
`ValidationSchemaFluent.EventNested<A>`	`withNewEventLike(Event item)`
`ValidationSchemaFluent.EventListNested<A>`	`withNewEventList()`
`ValidationSchemaFluent.EventListNested<A>`	`withNewEventListLike(EventList item)`
`ValidationSchemaFluent.EventSeriesNested<A>`	`withNewEventSeries()`
`ValidationSchemaFluent.EventSeriesNested<A>`	`withNewEventSeriesLike(EventSeries item)`
`ValidationSchemaFluent.EventSourceNested<A>`	`withNewEventSource()`
`A`	`withNewEventSource(String component, String host)`
`ValidationSchemaFluent.EventSourceNested<A>`	`withNewEventSourceLike(EventSource item)`
`ValidationSchemaFluent.GetOptionsNested<A>`	`withNewGetOptions()`
`A`	`withNewGetOptions(String apiVersion, String kind, String resourceVersion)`
`ValidationSchemaFluent.GetOptionsNested<A>`	`withNewGetOptionsLike(GetOptions item)`
`ValidationSchemaFluent.GroupKindNested<A>`	`withNewGroupKind()`
`A`	`withNewGroupKind(String group, String kind)`
`ValidationSchemaFluent.GroupKindNested<A>`	`withNewGroupKindLike(GroupKind item)`
`ValidationSchemaFluent.GroupVersionKindNested<A>`	`withNewGroupVersionKind()`
`A`	`withNewGroupVersionKind(String group, String kind, String version)`
`ValidationSchemaFluent.GroupVersionKindNested<A>`	`withNewGroupVersionKindLike(GroupVersionKind item)`
`ValidationSchemaFluent.GroupVersionResourceNested<A>`	`withNewGroupVersionResource()`
`A`	`withNewGroupVersionResource(String group, String resource, String version)`
`ValidationSchemaFluent.GroupVersionResourceNested<A>`	`withNewGroupVersionResourceLike(GroupVersionResource item)`
`ValidationSchemaFluent.InfoNested<A>`	`withNewInfo()`
`ValidationSchemaFluent.InfoNested<A>`	`withNewInfoLike(Info item)`
`ValidationSchemaFluent.KubernetesListNested<A>`	`withNewKubernetesList()`
`ValidationSchemaFluent.KubernetesListNested<A>`	`withNewKubernetesListLike(KubernetesList item)`
`ValidationSchemaFluent.LimitRangeListNested<A>`	`withNewLimitRangeList()`
`ValidationSchemaFluent.LimitRangeListNested<A>`	`withNewLimitRangeListLike(LimitRangeList item)`
`ValidationSchemaFluent.ListOptionsNested<A>`	`withNewListOptions()`
`ValidationSchemaFluent.ListOptionsNested<A>`	`withNewListOptionsLike(ListOptions item)`
`ValidationSchemaFluent.MicroTimeNested<A>`	`withNewMicroTime()`
`A`	`withNewMicroTime(String time)`
`ValidationSchemaFluent.MicroTimeNested<A>`	`withNewMicroTimeLike(MicroTime item)`
`ValidationSchemaFluent.NamespaceNested<A>`	`withNewNamespace()`
`ValidationSchemaFluent.NamespaceNested<A>`	`withNewNamespaceLike(Namespace item)`
`ValidationSchemaFluent.NamespaceListNested<A>`	`withNewNamespaceList()`
`ValidationSchemaFluent.NamespaceListNested<A>`	`withNewNamespaceListLike(NamespaceList item)`
`ValidationSchemaFluent.NodeNested<A>`	`withNewNode()`
`ValidationSchemaFluent.NodeNested<A>`	`withNewNodeLike(Node item)`
`ValidationSchemaFluent.NodeListNested<A>`	`withNewNodeList()`
`ValidationSchemaFluent.NodeListNested<A>`	`withNewNodeListLike(NodeList item)`
`ValidationSchemaFluent.ObjectMetaNested<A>`	`withNewObjectMeta()`
`ValidationSchemaFluent.ObjectMetaNested<A>`	`withNewObjectMetaLike(ObjectMeta item)`
`ValidationSchemaFluent.PatchNested<A>`	`withNewPatch()`
`ValidationSchemaFluent.PatchNested<A>`	`withNewPatchLike(Patch item)`
`ValidationSchemaFluent.PatchOptionsNested<A>`	`withNewPatchOptions()`
`ValidationSchemaFluent.PatchOptionsNested<A>`	`withNewPatchOptionsLike(PatchOptions item)`
`ValidationSchemaFluent.PersistentVolumeNested<A>`	`withNewPersistentVolume()`
`ValidationSchemaFluent.PersistentVolumeClaimNested<A>`	`withNewPersistentVolumeClaim()`
`ValidationSchemaFluent.PersistentVolumeClaimNested<A>`	`withNewPersistentVolumeClaimLike(PersistentVolumeClaim item)`
`ValidationSchemaFluent.PersistentVolumeClaimListNested<A>`	`withNewPersistentVolumeClaimList()`
`ValidationSchemaFluent.PersistentVolumeClaimListNested<A>`	`withNewPersistentVolumeClaimListLike(PersistentVolumeClaimList item)`
`ValidationSchemaFluent.PersistentVolumeNested<A>`	`withNewPersistentVolumeLike(PersistentVolume item)`
`ValidationSchemaFluent.PersistentVolumeListNested<A>`	`withNewPersistentVolumeList()`
`ValidationSchemaFluent.PersistentVolumeListNested<A>`	`withNewPersistentVolumeListLike(PersistentVolumeList item)`
`ValidationSchemaFluent.PodExecOptionsNested<A>`	`withNewPodExecOptions()`
`ValidationSchemaFluent.PodExecOptionsNested<A>`	`withNewPodExecOptionsLike(PodExecOptions item)`
`ValidationSchemaFluent.PodListNested<A>`	`withNewPodList()`
`ValidationSchemaFluent.PodListNested<A>`	`withNewPodListLike(PodList item)`
`ValidationSchemaFluent.PodTemplateListNested<A>`	`withNewPodTemplateList()`
`ValidationSchemaFluent.PodTemplateListNested<A>`	`withNewPodTemplateListLike(PodTemplateList item)`
`ValidationSchemaFluent.QuantityNested<A>`	`withNewQuantity()`
`A`	`withNewQuantity(String amount)`
`A`	`withNewQuantity(String amount, String format)`
`ValidationSchemaFluent.QuantityNested<A>`	`withNewQuantityLike(Quantity item)`
`ValidationSchemaFluent.ReplicationControllerListNested<A>`	`withNewReplicationControllerList()`
`ValidationSchemaFluent.ReplicationControllerListNested<A>`	`withNewReplicationControllerListLike(ReplicationControllerList item)`
`ValidationSchemaFluent.ResourceQuotaNested<A>`	`withNewResourceQuota()`
`ValidationSchemaFluent.ResourceQuotaNested<A>`	`withNewResourceQuotaLike(ResourceQuota item)`
`ValidationSchemaFluent.ResourceQuotaListNested<A>`	`withNewResourceQuotaList()`
`ValidationSchemaFluent.ResourceQuotaListNested<A>`	`withNewResourceQuotaListLike(ResourceQuotaList item)`
`ValidationSchemaFluent.RootPathsNested<A>`	`withNewRootPaths()`
`ValidationSchemaFluent.RootPathsNested<A>`	`withNewRootPathsLike(RootPaths item)`
`ValidationSchemaFluent.SecretNested<A>`	`withNewSecret()`
`ValidationSchemaFluent.SecretNested<A>`	`withNewSecretLike(Secret item)`
`ValidationSchemaFluent.SecretListNested<A>`	`withNewSecretList()`
`ValidationSchemaFluent.SecretListNested<A>`	`withNewSecretListLike(SecretList item)`
`ValidationSchemaFluent.ServiceAccountNested<A>`	`withNewServiceAccount()`
`ValidationSchemaFluent.ServiceAccountNested<A>`	`withNewServiceAccountLike(ServiceAccount item)`
`ValidationSchemaFluent.ServiceAccountListNested<A>`	`withNewServiceAccountList()`
`ValidationSchemaFluent.ServiceAccountListNested<A>`	`withNewServiceAccountListLike(ServiceAccountList item)`
`ValidationSchemaFluent.ServiceListNested<A>`	`withNewServiceList()`
`ValidationSchemaFluent.ServiceListNested<A>`	`withNewServiceListLike(ServiceList item)`
`ValidationSchemaFluent.StatusNested<A>`	`withNewStatus()`
`ValidationSchemaFluent.StatusNested<A>`	`withNewStatusLike(Status item)`
`ValidationSchemaFluent.TolerationNested<A>`	`withNewToleration()`
`A`	`withNewToleration(String effect, String key, String operator, Long tolerationSeconds, String value)`
`ValidationSchemaFluent.TolerationNested<A>`	`withNewTolerationLike(Toleration item)`
`ValidationSchemaFluent.TopologySelectorTermNested<A>`	`withNewTopologySelectorTerm()`
`ValidationSchemaFluent.TopologySelectorTermNested<A>`	`withNewTopologySelectorTermLike(TopologySelectorTerm item)`
`ValidationSchemaFluent.TypeMetaNested<A>`	`withNewTypeMeta()`
`A`	`withNewTypeMeta(String apiVersion, String kind)`
`ValidationSchemaFluent.TypeMetaNested<A>`	`withNewTypeMetaLike(TypeMeta item)`
`ValidationSchemaFluent.UpdateOptionsNested<A>`	`withNewUpdateOptions()`
`ValidationSchemaFluent.UpdateOptionsNested<A>`	`withNewUpdateOptionsLike(UpdateOptions item)`
`ValidationSchemaFluent.WatchEventNested<A>`	`withNewWatchEvent()`
`ValidationSchemaFluent.WatchEventNested<A>`	`withNewWatchEventLike(WatchEvent item)`
`A`	`withNode(Node node)`
`A`	`withNodeList(NodeList nodeList)`
`A`	`withObjectMeta(ObjectMeta objectMeta)`
`A`	`withPatch(Patch patch)`
`A`	`withPatchOptions(PatchOptions patchOptions)`
`A`	`withPersistentVolume(PersistentVolume persistentVolume)`
`A`	`withPersistentVolumeClaim(PersistentVolumeClaim persistentVolumeClaim)`
`A`	`withPersistentVolumeClaimList(PersistentVolumeClaimList persistentVolumeClaimList)`
`A`	`withPersistentVolumeList(PersistentVolumeList persistentVolumeList)`
`A`	`withPodExecOptions(PodExecOptions podExecOptions)`
`A`	`withPodList(PodList podList)`
`A`	`withPodTemplateList(PodTemplateList podTemplateList)`
`A`	`withQuantity(Quantity quantity)`
`A`	`withReplicationControllerList(ReplicationControllerList replicationControllerList)`
`A`	`withResourceQuota(ResourceQuota resourceQuota)`
`A`	`withResourceQuotaList(ResourceQuotaList resourceQuotaList)`
`A`	`withRootPaths(RootPaths rootPaths)`
`A`	`withSecret(Secret secret)`
`A`	`withSecretList(SecretList secretList)`
`A`	`withServiceAccount(ServiceAccount serviceAccount)`
`A`	`withServiceAccountList(ServiceAccountList serviceAccountList)`
`A`	`withServiceList(ServiceList serviceList)`
`A`	`withStatus(Status status)`
`A`	`withTime(String time)`
`A`	`withToleration(Toleration toleration)`
`A`	`withTopologySelectorTerm(TopologySelectorTerm topologySelectorTerm)`
`A`	`withTypeMeta(TypeMeta typeMeta)`
`A`	`withUpdateOptions(UpdateOptions updateOptions)`
`A`	`withWatchEvent(WatchEvent watchEvent)`

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
accept, accept, accept, accept, aggregate, aggregate, build, build, builderOf

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable
getTarget

Constructor Detail

ValidationSchemaFluent
```
public ValidationSchemaFluent()
```

ValidationSchemaFluent

public ValidationSchemaFluent(ValidationSchema instance)

Method Detail

buildAPIGroup
```
public APIGroup buildAPIGroup()
```

withAPIGroup

public A withAPIGroup(APIGroup aPIGroup)

hasAPIGroup
```
public boolean hasAPIGroup()
```

withNewAPIGroup

public ValidationSchemaFluent.APIGroupNested<A> withNewAPIGroup()

withNewAPIGroupLike

public ValidationSchemaFluent.APIGroupNested<A> withNewAPIGroupLike(APIGroup item)

editAPIGroup

public ValidationSchemaFluent.APIGroupNested<A> editAPIGroup()

editOrNewAPIGroup

public ValidationSchemaFluent.APIGroupNested<A> editOrNewAPIGroup()

editOrNewAPIGroupLike

public ValidationSchemaFluent.APIGroupNested<A> editOrNewAPIGroupLike(APIGroup item)

buildAPIGroupList

public APIGroupList buildAPIGroupList()

withAPIGroupList

public A withAPIGroupList(APIGroupList aPIGroupList)

hasAPIGroupList
```
public boolean hasAPIGroupList()
```

withNewAPIGroupList

public ValidationSchemaFluent.APIGroupListNested<A> withNewAPIGroupList()

withNewAPIGroupListLike

public ValidationSchemaFluent.APIGroupListNested<A> withNewAPIGroupListLike(APIGroupList item)

editAPIGroupList

public ValidationSchemaFluent.APIGroupListNested<A> editAPIGroupList()

editOrNewAPIGroupList

public ValidationSchemaFluent.APIGroupListNested<A> editOrNewAPIGroupList()

editOrNewAPIGroupListLike

public ValidationSchemaFluent.APIGroupListNested<A> editOrNewAPIGroupListLike(APIGroupList item)

buildAPIResource
```
public APIResource buildAPIResource()
```

withAPIResource

public A withAPIResource(APIResource aPIResource)

hasAPIResource
```
public boolean hasAPIResource()
```

withNewAPIResource

public ValidationSchemaFluent.APIResourceNested<A> withNewAPIResource()

withNewAPIResourceLike

public ValidationSchemaFluent.APIResourceNested<A> withNewAPIResourceLike(APIResource item)

editAPIResource

public ValidationSchemaFluent.APIResourceNested<A> editAPIResource()

editOrNewAPIResource

public ValidationSchemaFluent.APIResourceNested<A> editOrNewAPIResource()

editOrNewAPIResourceLike

public ValidationSchemaFluent.APIResourceNested<A> editOrNewAPIResourceLike(APIResource item)

buildAPIResourceList

public APIResourceList buildAPIResourceList()

withAPIResourceList

public A withAPIResourceList(APIResourceList aPIResourceList)

hasAPIResourceList
```
public boolean hasAPIResourceList()
```

withNewAPIResourceList

public ValidationSchemaFluent.APIResourceListNested<A> withNewAPIResourceList()

withNewAPIResourceListLike

public ValidationSchemaFluent.APIResourceListNested<A> withNewAPIResourceListLike(APIResourceList item)

editAPIResourceList

public ValidationSchemaFluent.APIResourceListNested<A> editAPIResourceList()

editOrNewAPIResourceList

public ValidationSchemaFluent.APIResourceListNested<A> editOrNewAPIResourceList()

editOrNewAPIResourceListLike

public ValidationSchemaFluent.APIResourceListNested<A> editOrNewAPIResourceListLike(APIResourceList item)

buildAPIService
```
public APIService buildAPIService()
```

withAPIService

public A withAPIService(APIService aPIService)

hasAPIService
```
public boolean hasAPIService()
```

withNewAPIService

public ValidationSchemaFluent.APIServiceNested<A> withNewAPIService()

withNewAPIServiceLike

public ValidationSchemaFluent.APIServiceNested<A> withNewAPIServiceLike(APIService item)

editAPIService

public ValidationSchemaFluent.APIServiceNested<A> editAPIService()

editOrNewAPIService

public ValidationSchemaFluent.APIServiceNested<A> editOrNewAPIService()

editOrNewAPIServiceLike

public ValidationSchemaFluent.APIServiceNested<A> editOrNewAPIServiceLike(APIService item)

buildAPIServiceList

public APIServiceList buildAPIServiceList()

withAPIServiceList

public A withAPIServiceList(APIServiceList aPIServiceList)

hasAPIServiceList
```
public boolean hasAPIServiceList()
```

withNewAPIServiceList

public ValidationSchemaFluent.APIServiceListNested<A> withNewAPIServiceList()

withNewAPIServiceListLike

public ValidationSchemaFluent.APIServiceListNested<A> withNewAPIServiceListLike(APIServiceList item)

editAPIServiceList

public ValidationSchemaFluent.APIServiceListNested<A> editAPIServiceList()

editOrNewAPIServiceList

public ValidationSchemaFluent.APIServiceListNested<A> editOrNewAPIServiceList()

editOrNewAPIServiceListLike

public ValidationSchemaFluent.APIServiceListNested<A> editOrNewAPIServiceListLike(APIServiceList item)

buildBinding
```
public Binding buildBinding()
```

withBinding

public A withBinding(Binding binding)

hasBinding
```
public boolean hasBinding()
```

withNewBinding

public ValidationSchemaFluent.BindingNested<A> withNewBinding()

withNewBindingLike

public ValidationSchemaFluent.BindingNested<A> withNewBindingLike(Binding item)

editBinding

public ValidationSchemaFluent.BindingNested<A> editBinding()

editOrNewBinding

public ValidationSchemaFluent.BindingNested<A> editOrNewBinding()

editOrNewBindingLike

public ValidationSchemaFluent.BindingNested<A> editOrNewBindingLike(Binding item)

buildComponentStatus

public ComponentStatus buildComponentStatus()

withComponentStatus

public A withComponentStatus(ComponentStatus componentStatus)

hasComponentStatus
```
public boolean hasComponentStatus()
```

withNewComponentStatus

public ValidationSchemaFluent.ComponentStatusNested<A> withNewComponentStatus()

withNewComponentStatusLike

public ValidationSchemaFluent.ComponentStatusNested<A> withNewComponentStatusLike(ComponentStatus item)

editComponentStatus

public ValidationSchemaFluent.ComponentStatusNested<A> editComponentStatus()

editOrNewComponentStatus

public ValidationSchemaFluent.ComponentStatusNested<A> editOrNewComponentStatus()

editOrNewComponentStatusLike

public ValidationSchemaFluent.ComponentStatusNested<A> editOrNewComponentStatusLike(ComponentStatus item)

buildComponentStatusList

public ComponentStatusList buildComponentStatusList()

withComponentStatusList

public A withComponentStatusList(ComponentStatusList componentStatusList)

hasComponentStatusList

public boolean hasComponentStatusList()

withNewComponentStatusList

public ValidationSchemaFluent.ComponentStatusListNested<A> withNewComponentStatusList()

withNewComponentStatusListLike

public ValidationSchemaFluent.ComponentStatusListNested<A> withNewComponentStatusListLike(ComponentStatusList item)

editComponentStatusList

public ValidationSchemaFluent.ComponentStatusListNested<A> editComponentStatusList()

editOrNewComponentStatusList

public ValidationSchemaFluent.ComponentStatusListNested<A> editOrNewComponentStatusList()

editOrNewComponentStatusListLike

public ValidationSchemaFluent.ComponentStatusListNested<A> editOrNewComponentStatusListLike(ComponentStatusList item)

buildCondition
```
public Condition buildCondition()
```

withCondition

public A withCondition(Condition condition)

hasCondition
```
public boolean hasCondition()
```

withNewCondition

public ValidationSchemaFluent.ConditionNested<A> withNewCondition()

withNewConditionLike

public ValidationSchemaFluent.ConditionNested<A> withNewConditionLike(Condition item)

editCondition

public ValidationSchemaFluent.ConditionNested<A> editCondition()

editOrNewCondition

public ValidationSchemaFluent.ConditionNested<A> editOrNewCondition()

editOrNewConditionLike

public ValidationSchemaFluent.ConditionNested<A> editOrNewConditionLike(Condition item)

buildConfig
```
public Config buildConfig()
```

withConfig
```
public A withConfig(Config config)
```

hasConfig
```
public boolean hasConfig()
```

withNewConfig

public ValidationSchemaFluent.ConfigNested<A> withNewConfig()

withNewConfigLike

public ValidationSchemaFluent.ConfigNested<A> withNewConfigLike(Config item)

editConfig

public ValidationSchemaFluent.ConfigNested<A> editConfig()

editOrNewConfig

public ValidationSchemaFluent.ConfigNested<A> editOrNewConfig()

editOrNewConfigLike

public ValidationSchemaFluent.ConfigNested<A> editOrNewConfigLike(Config item)

buildConfigMap
```
public ConfigMap buildConfigMap()
```

withConfigMap

public A withConfigMap(ConfigMap configMap)

hasConfigMap
```
public boolean hasConfigMap()
```

withNewConfigMap

public ValidationSchemaFluent.ConfigMapNested<A> withNewConfigMap()

withNewConfigMapLike

public ValidationSchemaFluent.ConfigMapNested<A> withNewConfigMapLike(ConfigMap item)

editConfigMap

public ValidationSchemaFluent.ConfigMapNested<A> editConfigMap()

editOrNewConfigMap

public ValidationSchemaFluent.ConfigMapNested<A> editOrNewConfigMap()

editOrNewConfigMapLike

public ValidationSchemaFluent.ConfigMapNested<A> editOrNewConfigMapLike(ConfigMap item)

buildConfigMapList

public ConfigMapList buildConfigMapList()

withConfigMapList

public A withConfigMapList(ConfigMapList configMapList)

hasConfigMapList
```
public boolean hasConfigMapList()
```

withNewConfigMapList

public ValidationSchemaFluent.ConfigMapListNested<A> withNewConfigMapList()

withNewConfigMapListLike

public ValidationSchemaFluent.ConfigMapListNested<A> withNewConfigMapListLike(ConfigMapList item)

editConfigMapList

public ValidationSchemaFluent.ConfigMapListNested<A> editConfigMapList()

editOrNewConfigMapList

public ValidationSchemaFluent.ConfigMapListNested<A> editOrNewConfigMapList()

editOrNewConfigMapListLike

public ValidationSchemaFluent.ConfigMapListNested<A> editOrNewConfigMapListLike(ConfigMapList item)

buildContainerStatus

public ContainerStatus buildContainerStatus()

withContainerStatus

public A withContainerStatus(ContainerStatus containerStatus)

hasContainerStatus
```
public boolean hasContainerStatus()
```

withNewContainerStatus

public ValidationSchemaFluent.ContainerStatusNested<A> withNewContainerStatus()

withNewContainerStatusLike

public ValidationSchemaFluent.ContainerStatusNested<A> withNewContainerStatusLike(ContainerStatus item)

editContainerStatus

public ValidationSchemaFluent.ContainerStatusNested<A> editContainerStatus()

editOrNewContainerStatus

public ValidationSchemaFluent.ContainerStatusNested<A> editOrNewContainerStatus()

editOrNewContainerStatusLike

public ValidationSchemaFluent.ContainerStatusNested<A> editOrNewContainerStatusLike(ContainerStatus item)

buildCreateOptions

public CreateOptions buildCreateOptions()

withCreateOptions

public A withCreateOptions(CreateOptions createOptions)

hasCreateOptions
```
public boolean hasCreateOptions()
```

withNewCreateOptions

public ValidationSchemaFluent.CreateOptionsNested<A> withNewCreateOptions()

withNewCreateOptionsLike

public ValidationSchemaFluent.CreateOptionsNested<A> withNewCreateOptionsLike(CreateOptions item)

editCreateOptions

public ValidationSchemaFluent.CreateOptionsNested<A> editCreateOptions()

editOrNewCreateOptions

public ValidationSchemaFluent.CreateOptionsNested<A> editOrNewCreateOptions()

editOrNewCreateOptionsLike

public ValidationSchemaFluent.CreateOptionsNested<A> editOrNewCreateOptionsLike(CreateOptions item)

buildDeleteOptions

public DeleteOptions buildDeleteOptions()

withDeleteOptions

public A withDeleteOptions(DeleteOptions deleteOptions)

hasDeleteOptions
```
public boolean hasDeleteOptions()
```

withNewDeleteOptions

public ValidationSchemaFluent.DeleteOptionsNested<A> withNewDeleteOptions()

withNewDeleteOptionsLike

public ValidationSchemaFluent.DeleteOptionsNested<A> withNewDeleteOptionsLike(DeleteOptions item)

editDeleteOptions

public ValidationSchemaFluent.DeleteOptionsNested<A> editDeleteOptions()

editOrNewDeleteOptions

public ValidationSchemaFluent.DeleteOptionsNested<A> editOrNewDeleteOptions()

editOrNewDeleteOptionsLike

public ValidationSchemaFluent.DeleteOptionsNested<A> editOrNewDeleteOptionsLike(DeleteOptions item)

buildEndpointPort

public EndpointPort buildEndpointPort()

withEndpointPort

public A withEndpointPort(EndpointPort endpointPort)

hasEndpointPort
```
public boolean hasEndpointPort()
```

withNewEndpointPort

public A withNewEndpointPort(String appProtocol,
                             String name,
                             Integer port,
                             String protocol)

withNewEndpointPort

public ValidationSchemaFluent.EndpointPortNested<A> withNewEndpointPort()

withNewEndpointPortLike

public ValidationSchemaFluent.EndpointPortNested<A> withNewEndpointPortLike(EndpointPort item)

editEndpointPort

public ValidationSchemaFluent.EndpointPortNested<A> editEndpointPort()

editOrNewEndpointPort

public ValidationSchemaFluent.EndpointPortNested<A> editOrNewEndpointPort()

editOrNewEndpointPortLike

public ValidationSchemaFluent.EndpointPortNested<A> editOrNewEndpointPortLike(EndpointPort item)

buildEndpoints
```
public Endpoints buildEndpoints()
```

withEndpoints

public A withEndpoints(Endpoints endpoints)

hasEndpoints
```
public boolean hasEndpoints()
```

withNewEndpoints

public ValidationSchemaFluent.EndpointsNested<A> withNewEndpoints()

withNewEndpointsLike

public ValidationSchemaFluent.EndpointsNested<A> withNewEndpointsLike(Endpoints item)

editEndpoints

public ValidationSchemaFluent.EndpointsNested<A> editEndpoints()

editOrNewEndpoints

public ValidationSchemaFluent.EndpointsNested<A> editOrNewEndpoints()

editOrNewEndpointsLike

public ValidationSchemaFluent.EndpointsNested<A> editOrNewEndpointsLike(Endpoints item)

buildEndpointsList

public EndpointsList buildEndpointsList()

withEndpointsList

public A withEndpointsList(EndpointsList endpointsList)

hasEndpointsList
```
public boolean hasEndpointsList()
```

withNewEndpointsList

public ValidationSchemaFluent.EndpointsListNested<A> withNewEndpointsList()

withNewEndpointsListLike

public ValidationSchemaFluent.EndpointsListNested<A> withNewEndpointsListLike(EndpointsList item)

editEndpointsList

public ValidationSchemaFluent.EndpointsListNested<A> editEndpointsList()

editOrNewEndpointsList

public ValidationSchemaFluent.EndpointsListNested<A> editOrNewEndpointsList()

editOrNewEndpointsListLike

public ValidationSchemaFluent.EndpointsListNested<A> editOrNewEndpointsListLike(EndpointsList item)

buildEnvVar
```
public EnvVar buildEnvVar()
```

withEnvVar
```
public A withEnvVar(EnvVar envVar)
```

hasEnvVar
```
public boolean hasEnvVar()
```

withNewEnvVar

public ValidationSchemaFluent.EnvVarNested<A> withNewEnvVar()

withNewEnvVarLike

public ValidationSchemaFluent.EnvVarNested<A> withNewEnvVarLike(EnvVar item)

editEnvVar

public ValidationSchemaFluent.EnvVarNested<A> editEnvVar()

editOrNewEnvVar

public ValidationSchemaFluent.EnvVarNested<A> editOrNewEnvVar()

editOrNewEnvVarLike

public ValidationSchemaFluent.EnvVarNested<A> editOrNewEnvVarLike(EnvVar item)

buildEvent
```
public Event buildEvent()
```

withEvent
```
public A withEvent(Event event)
```

hasEvent
```
public boolean hasEvent()
```

withNewEvent

public ValidationSchemaFluent.EventNested<A> withNewEvent()

withNewEventLike

public ValidationSchemaFluent.EventNested<A> withNewEventLike(Event item)

editEvent

public ValidationSchemaFluent.EventNested<A> editEvent()

editOrNewEvent

public ValidationSchemaFluent.EventNested<A> editOrNewEvent()

editOrNewEventLike

public ValidationSchemaFluent.EventNested<A> editOrNewEventLike(Event item)

buildEventList
```
public EventList buildEventList()
```

withEventList

public A withEventList(EventList eventList)

hasEventList
```
public boolean hasEventList()
```

withNewEventList

public ValidationSchemaFluent.EventListNested<A> withNewEventList()

withNewEventListLike

public ValidationSchemaFluent.EventListNested<A> withNewEventListLike(EventList item)

editEventList

public ValidationSchemaFluent.EventListNested<A> editEventList()

editOrNewEventList

public ValidationSchemaFluent.EventListNested<A> editOrNewEventList()

editOrNewEventListLike

public ValidationSchemaFluent.EventListNested<A> editOrNewEventListLike(EventList item)

buildEventSeries
```
public EventSeries buildEventSeries()
```

withEventSeries

public A withEventSeries(EventSeries eventSeries)

hasEventSeries
```
public boolean hasEventSeries()
```

withNewEventSeries

public ValidationSchemaFluent.EventSeriesNested<A> withNewEventSeries()

withNewEventSeriesLike

public ValidationSchemaFluent.EventSeriesNested<A> withNewEventSeriesLike(EventSeries item)

editEventSeries

public ValidationSchemaFluent.EventSeriesNested<A> editEventSeries()

editOrNewEventSeries

public ValidationSchemaFluent.EventSeriesNested<A> editOrNewEventSeries()

editOrNewEventSeriesLike

public ValidationSchemaFluent.EventSeriesNested<A> editOrNewEventSeriesLike(EventSeries item)

buildEventSource
```
public EventSource buildEventSource()
```

withEventSource

public A withEventSource(EventSource eventSource)

hasEventSource
```
public boolean hasEventSource()
```

withNewEventSource

public A withNewEventSource(String component,
                            String host)

withNewEventSource

public ValidationSchemaFluent.EventSourceNested<A> withNewEventSource()

withNewEventSourceLike

public ValidationSchemaFluent.EventSourceNested<A> withNewEventSourceLike(EventSource item)

editEventSource

public ValidationSchemaFluent.EventSourceNested<A> editEventSource()

editOrNewEventSource

public ValidationSchemaFluent.EventSourceNested<A> editOrNewEventSource()

editOrNewEventSourceLike

public ValidationSchemaFluent.EventSourceNested<A> editOrNewEventSourceLike(EventSource item)

buildGetOptions
```
public GetOptions buildGetOptions()
```

withGetOptions

public A withGetOptions(GetOptions getOptions)

hasGetOptions
```
public boolean hasGetOptions()
```

withNewGetOptions

public A withNewGetOptions(String apiVersion,
                           String kind,
                           String resourceVersion)

withNewGetOptions

public ValidationSchemaFluent.GetOptionsNested<A> withNewGetOptions()

withNewGetOptionsLike

public ValidationSchemaFluent.GetOptionsNested<A> withNewGetOptionsLike(GetOptions item)

editGetOptions

public ValidationSchemaFluent.GetOptionsNested<A> editGetOptions()

editOrNewGetOptions

public ValidationSchemaFluent.GetOptionsNested<A> editOrNewGetOptions()

editOrNewGetOptionsLike

public ValidationSchemaFluent.GetOptionsNested<A> editOrNewGetOptionsLike(GetOptions item)

buildGroupKind
```
public GroupKind buildGroupKind()
```

withGroupKind

public A withGroupKind(GroupKind groupKind)

hasGroupKind
```
public boolean hasGroupKind()
```

withNewGroupKind

public A withNewGroupKind(String group,
                          String kind)

withNewGroupKind

public ValidationSchemaFluent.GroupKindNested<A> withNewGroupKind()

withNewGroupKindLike

public ValidationSchemaFluent.GroupKindNested<A> withNewGroupKindLike(GroupKind item)

editGroupKind

public ValidationSchemaFluent.GroupKindNested<A> editGroupKind()

editOrNewGroupKind

public ValidationSchemaFluent.GroupKindNested<A> editOrNewGroupKind()

editOrNewGroupKindLike

public ValidationSchemaFluent.GroupKindNested<A> editOrNewGroupKindLike(GroupKind item)

buildGroupVersionKind

public GroupVersionKind buildGroupVersionKind()

withGroupVersionKind

public A withGroupVersionKind(GroupVersionKind groupVersionKind)

hasGroupVersionKind
```
public boolean hasGroupVersionKind()
```

withNewGroupVersionKind

public A withNewGroupVersionKind(String group,
                                 String kind,
                                 String version)

withNewGroupVersionKind

public ValidationSchemaFluent.GroupVersionKindNested<A> withNewGroupVersionKind()

withNewGroupVersionKindLike

public ValidationSchemaFluent.GroupVersionKindNested<A> withNewGroupVersionKindLike(GroupVersionKind item)

editGroupVersionKind

public ValidationSchemaFluent.GroupVersionKindNested<A> editGroupVersionKind()

editOrNewGroupVersionKind

public ValidationSchemaFluent.GroupVersionKindNested<A> editOrNewGroupVersionKind()

editOrNewGroupVersionKindLike

public ValidationSchemaFluent.GroupVersionKindNested<A> editOrNewGroupVersionKindLike(GroupVersionKind item)

buildGroupVersionResource

public GroupVersionResource buildGroupVersionResource()

withGroupVersionResource

public A withGroupVersionResource(GroupVersionResource groupVersionResource)

hasGroupVersionResource

public boolean hasGroupVersionResource()

withNewGroupVersionResource

public A withNewGroupVersionResource(String group,
                                     String resource,
                                     String version)

withNewGroupVersionResource

public ValidationSchemaFluent.GroupVersionResourceNested<A> withNewGroupVersionResource()

withNewGroupVersionResourceLike

public ValidationSchemaFluent.GroupVersionResourceNested<A> withNewGroupVersionResourceLike(GroupVersionResource item)

editGroupVersionResource

public ValidationSchemaFluent.GroupVersionResourceNested<A> editGroupVersionResource()

editOrNewGroupVersionResource

public ValidationSchemaFluent.GroupVersionResourceNested<A> editOrNewGroupVersionResource()

editOrNewGroupVersionResourceLike

public ValidationSchemaFluent.GroupVersionResourceNested<A> editOrNewGroupVersionResourceLike(GroupVersionResource item)

buildInfo
```
public Info buildInfo()
```

withInfo
```
public A withInfo(Info info)
```

hasInfo
```
public boolean hasInfo()
```

withNewInfo

public ValidationSchemaFluent.InfoNested<A> withNewInfo()

withNewInfoLike

public ValidationSchemaFluent.InfoNested<A> withNewInfoLike(Info item)

editInfo

public ValidationSchemaFluent.InfoNested<A> editInfo()

editOrNewInfo

public ValidationSchemaFluent.InfoNested<A> editOrNewInfo()

editOrNewInfoLike

public ValidationSchemaFluent.InfoNested<A> editOrNewInfoLike(Info item)

buildKubernetesList

public KubernetesList buildKubernetesList()

withKubernetesList

public A withKubernetesList(KubernetesList kubernetesList)

hasKubernetesList
```
public boolean hasKubernetesList()
```

withNewKubernetesList

public ValidationSchemaFluent.KubernetesListNested<A> withNewKubernetesList()

withNewKubernetesListLike

public ValidationSchemaFluent.KubernetesListNested<A> withNewKubernetesListLike(KubernetesList item)

editKubernetesList

public ValidationSchemaFluent.KubernetesListNested<A> editKubernetesList()

editOrNewKubernetesList

public ValidationSchemaFluent.KubernetesListNested<A> editOrNewKubernetesList()

editOrNewKubernetesListLike

public ValidationSchemaFluent.KubernetesListNested<A> editOrNewKubernetesListLike(KubernetesList item)

buildLimitRangeList

public LimitRangeList buildLimitRangeList()

withLimitRangeList

public A withLimitRangeList(LimitRangeList limitRangeList)

hasLimitRangeList
```
public boolean hasLimitRangeList()
```

withNewLimitRangeList

public ValidationSchemaFluent.LimitRangeListNested<A> withNewLimitRangeList()

withNewLimitRangeListLike

public ValidationSchemaFluent.LimitRangeListNested<A> withNewLimitRangeListLike(LimitRangeList item)

editLimitRangeList

public ValidationSchemaFluent.LimitRangeListNested<A> editLimitRangeList()

editOrNewLimitRangeList

public ValidationSchemaFluent.LimitRangeListNested<A> editOrNewLimitRangeList()

editOrNewLimitRangeListLike

public ValidationSchemaFluent.LimitRangeListNested<A> editOrNewLimitRangeListLike(LimitRangeList item)

buildListOptions
```
public ListOptions buildListOptions()
```

withListOptions

public A withListOptions(ListOptions listOptions)

hasListOptions
```
public boolean hasListOptions()
```

withNewListOptions

public ValidationSchemaFluent.ListOptionsNested<A> withNewListOptions()

withNewListOptionsLike

public ValidationSchemaFluent.ListOptionsNested<A> withNewListOptionsLike(ListOptions item)

editListOptions

public ValidationSchemaFluent.ListOptionsNested<A> editListOptions()

editOrNewListOptions

public ValidationSchemaFluent.ListOptionsNested<A> editOrNewListOptions()

editOrNewListOptionsLike

public ValidationSchemaFluent.ListOptionsNested<A> editOrNewListOptionsLike(ListOptions item)

buildMicroTime
```
public MicroTime buildMicroTime()
```

withMicroTime

public A withMicroTime(MicroTime microTime)

hasMicroTime
```
public boolean hasMicroTime()
```

withNewMicroTime

public A withNewMicroTime(String time)

withNewMicroTime

public ValidationSchemaFluent.MicroTimeNested<A> withNewMicroTime()

withNewMicroTimeLike

public ValidationSchemaFluent.MicroTimeNested<A> withNewMicroTimeLike(MicroTime item)

editMicroTime

public ValidationSchemaFluent.MicroTimeNested<A> editMicroTime()

editOrNewMicroTime

public ValidationSchemaFluent.MicroTimeNested<A> editOrNewMicroTime()

editOrNewMicroTimeLike

public ValidationSchemaFluent.MicroTimeNested<A> editOrNewMicroTimeLike(MicroTime item)

buildNamespace
```
public Namespace buildNamespace()
```

withNamespace

public A withNamespace(Namespace namespace)

hasNamespace
```
public boolean hasNamespace()
```

withNewNamespace

public ValidationSchemaFluent.NamespaceNested<A> withNewNamespace()

withNewNamespaceLike

public ValidationSchemaFluent.NamespaceNested<A> withNewNamespaceLike(Namespace item)

editNamespace

public ValidationSchemaFluent.NamespaceNested<A> editNamespace()

editOrNewNamespace

public ValidationSchemaFluent.NamespaceNested<A> editOrNewNamespace()

editOrNewNamespaceLike

public ValidationSchemaFluent.NamespaceNested<A> editOrNewNamespaceLike(Namespace item)

buildNamespaceList

public NamespaceList buildNamespaceList()

withNamespaceList

public A withNamespaceList(NamespaceList namespaceList)

hasNamespaceList
```
public boolean hasNamespaceList()
```

withNewNamespaceList

public ValidationSchemaFluent.NamespaceListNested<A> withNewNamespaceList()

withNewNamespaceListLike

public ValidationSchemaFluent.NamespaceListNested<A> withNewNamespaceListLike(NamespaceList item)

editNamespaceList

public ValidationSchemaFluent.NamespaceListNested<A> editNamespaceList()

editOrNewNamespaceList

public ValidationSchemaFluent.NamespaceListNested<A> editOrNewNamespaceList()

editOrNewNamespaceListLike

public ValidationSchemaFluent.NamespaceListNested<A> editOrNewNamespaceListLike(NamespaceList item)

buildNode
```
public Node buildNode()
```

withNode
```
public A withNode(Node node)
```

hasNode
```
public boolean hasNode()
```

withNewNode

public ValidationSchemaFluent.NodeNested<A> withNewNode()

withNewNodeLike

public ValidationSchemaFluent.NodeNested<A> withNewNodeLike(Node item)

editNode

public ValidationSchemaFluent.NodeNested<A> editNode()

editOrNewNode

public ValidationSchemaFluent.NodeNested<A> editOrNewNode()

editOrNewNodeLike

public ValidationSchemaFluent.NodeNested<A> editOrNewNodeLike(Node item)

buildNodeList
```
public NodeList buildNodeList()
```

withNodeList

public A withNodeList(NodeList nodeList)

hasNodeList
```
public boolean hasNodeList()
```

withNewNodeList

public ValidationSchemaFluent.NodeListNested<A> withNewNodeList()

withNewNodeListLike

public ValidationSchemaFluent.NodeListNested<A> withNewNodeListLike(NodeList item)

editNodeList

public ValidationSchemaFluent.NodeListNested<A> editNodeList()

editOrNewNodeList

public ValidationSchemaFluent.NodeListNested<A> editOrNewNodeList()

editOrNewNodeListLike

public ValidationSchemaFluent.NodeListNested<A> editOrNewNodeListLike(NodeList item)

buildObjectMeta
```
public ObjectMeta buildObjectMeta()
```

withObjectMeta

public A withObjectMeta(ObjectMeta objectMeta)

hasObjectMeta
```
public boolean hasObjectMeta()
```

withNewObjectMeta

public ValidationSchemaFluent.ObjectMetaNested<A> withNewObjectMeta()

withNewObjectMetaLike

public ValidationSchemaFluent.ObjectMetaNested<A> withNewObjectMetaLike(ObjectMeta item)

editObjectMeta

public ValidationSchemaFluent.ObjectMetaNested<A> editObjectMeta()

editOrNewObjectMeta

public ValidationSchemaFluent.ObjectMetaNested<A> editOrNewObjectMeta()

editOrNewObjectMetaLike

public ValidationSchemaFluent.ObjectMetaNested<A> editOrNewObjectMetaLike(ObjectMeta item)

buildPatch
```
public Patch buildPatch()
```

withPatch
```
public A withPatch(Patch patch)
```

hasPatch
```
public boolean hasPatch()
```

withNewPatch

public ValidationSchemaFluent.PatchNested<A> withNewPatch()

withNewPatchLike

public ValidationSchemaFluent.PatchNested<A> withNewPatchLike(Patch item)

editPatch

public ValidationSchemaFluent.PatchNested<A> editPatch()

editOrNewPatch

public ValidationSchemaFluent.PatchNested<A> editOrNewPatch()

editOrNewPatchLike

public ValidationSchemaFluent.PatchNested<A> editOrNewPatchLike(Patch item)

buildPatchOptions

public PatchOptions buildPatchOptions()

withPatchOptions

public A withPatchOptions(PatchOptions patchOptions)

hasPatchOptions
```
public boolean hasPatchOptions()
```

withNewPatchOptions

public ValidationSchemaFluent.PatchOptionsNested<A> withNewPatchOptions()

withNewPatchOptionsLike

public ValidationSchemaFluent.PatchOptionsNested<A> withNewPatchOptionsLike(PatchOptions item)

editPatchOptions

public ValidationSchemaFluent.PatchOptionsNested<A> editPatchOptions()

editOrNewPatchOptions

public ValidationSchemaFluent.PatchOptionsNested<A> editOrNewPatchOptions()

editOrNewPatchOptionsLike

public ValidationSchemaFluent.PatchOptionsNested<A> editOrNewPatchOptionsLike(PatchOptions item)

buildPersistentVolume

public PersistentVolume buildPersistentVolume()

withPersistentVolume

public A withPersistentVolume(PersistentVolume persistentVolume)

hasPersistentVolume
```
public boolean hasPersistentVolume()
```

withNewPersistentVolume

public ValidationSchemaFluent.PersistentVolumeNested<A> withNewPersistentVolume()

withNewPersistentVolumeLike

public ValidationSchemaFluent.PersistentVolumeNested<A> withNewPersistentVolumeLike(PersistentVolume item)

editPersistentVolume

public ValidationSchemaFluent.PersistentVolumeNested<A> editPersistentVolume()

editOrNewPersistentVolume

public ValidationSchemaFluent.PersistentVolumeNested<A> editOrNewPersistentVolume()

editOrNewPersistentVolumeLike

public ValidationSchemaFluent.PersistentVolumeNested<A> editOrNewPersistentVolumeLike(PersistentVolume item)

buildPersistentVolumeClaim

public PersistentVolumeClaim buildPersistentVolumeClaim()

withPersistentVolumeClaim

public A withPersistentVolumeClaim(PersistentVolumeClaim persistentVolumeClaim)

hasPersistentVolumeClaim

public boolean hasPersistentVolumeClaim()

withNewPersistentVolumeClaim

public ValidationSchemaFluent.PersistentVolumeClaimNested<A> withNewPersistentVolumeClaim()

withNewPersistentVolumeClaimLike

public ValidationSchemaFluent.PersistentVolumeClaimNested<A> withNewPersistentVolumeClaimLike(PersistentVolumeClaim item)

editPersistentVolumeClaim

public ValidationSchemaFluent.PersistentVolumeClaimNested<A> editPersistentVolumeClaim()

editOrNewPersistentVolumeClaim

public ValidationSchemaFluent.PersistentVolumeClaimNested<A> editOrNewPersistentVolumeClaim()

editOrNewPersistentVolumeClaimLike

public ValidationSchemaFluent.PersistentVolumeClaimNested<A> editOrNewPersistentVolumeClaimLike(PersistentVolumeClaim item)

buildPersistentVolumeClaimList

public PersistentVolumeClaimList buildPersistentVolumeClaimList()

withPersistentVolumeClaimList

public A withPersistentVolumeClaimList(PersistentVolumeClaimList persistentVolumeClaimList)

hasPersistentVolumeClaimList

public boolean hasPersistentVolumeClaimList()

withNewPersistentVolumeClaimList

public ValidationSchemaFluent.PersistentVolumeClaimListNested<A> withNewPersistentVolumeClaimList()

withNewPersistentVolumeClaimListLike

public ValidationSchemaFluent.PersistentVolumeClaimListNested<A> withNewPersistentVolumeClaimListLike(PersistentVolumeClaimList item)

editPersistentVolumeClaimList

public ValidationSchemaFluent.PersistentVolumeClaimListNested<A> editPersistentVolumeClaimList()

editOrNewPersistentVolumeClaimList

public ValidationSchemaFluent.PersistentVolumeClaimListNested<A> editOrNewPersistentVolumeClaimList()

editOrNewPersistentVolumeClaimListLike

public ValidationSchemaFluent.PersistentVolumeClaimListNested<A> editOrNewPersistentVolumeClaimListLike(PersistentVolumeClaimList item)

buildPersistentVolumeList

public PersistentVolumeList buildPersistentVolumeList()

withPersistentVolumeList

public A withPersistentVolumeList(PersistentVolumeList persistentVolumeList)

hasPersistentVolumeList

public boolean hasPersistentVolumeList()

withNewPersistentVolumeList

public ValidationSchemaFluent.PersistentVolumeListNested<A> withNewPersistentVolumeList()

withNewPersistentVolumeListLike

public ValidationSchemaFluent.PersistentVolumeListNested<A> withNewPersistentVolumeListLike(PersistentVolumeList item)

editPersistentVolumeList

public ValidationSchemaFluent.PersistentVolumeListNested<A> editPersistentVolumeList()

editOrNewPersistentVolumeList

public ValidationSchemaFluent.PersistentVolumeListNested<A> editOrNewPersistentVolumeList()

editOrNewPersistentVolumeListLike

public ValidationSchemaFluent.PersistentVolumeListNested<A> editOrNewPersistentVolumeListLike(PersistentVolumeList item)

buildPodExecOptions

public PodExecOptions buildPodExecOptions()

withPodExecOptions

public A withPodExecOptions(PodExecOptions podExecOptions)

hasPodExecOptions
```
public boolean hasPodExecOptions()
```

withNewPodExecOptions

public ValidationSchemaFluent.PodExecOptionsNested<A> withNewPodExecOptions()

withNewPodExecOptionsLike

public ValidationSchemaFluent.PodExecOptionsNested<A> withNewPodExecOptionsLike(PodExecOptions item)

editPodExecOptions

public ValidationSchemaFluent.PodExecOptionsNested<A> editPodExecOptions()

editOrNewPodExecOptions

public ValidationSchemaFluent.PodExecOptionsNested<A> editOrNewPodExecOptions()

editOrNewPodExecOptionsLike

public ValidationSchemaFluent.PodExecOptionsNested<A> editOrNewPodExecOptionsLike(PodExecOptions item)

buildPodList
```
public PodList buildPodList()
```

withPodList

public A withPodList(PodList podList)

hasPodList
```
public boolean hasPodList()
```

withNewPodList

public ValidationSchemaFluent.PodListNested<A> withNewPodList()

withNewPodListLike

public ValidationSchemaFluent.PodListNested<A> withNewPodListLike(PodList item)

editPodList

public ValidationSchemaFluent.PodListNested<A> editPodList()

editOrNewPodList

public ValidationSchemaFluent.PodListNested<A> editOrNewPodList()

editOrNewPodListLike

public ValidationSchemaFluent.PodListNested<A> editOrNewPodListLike(PodList item)

buildPodTemplateList

public PodTemplateList buildPodTemplateList()

withPodTemplateList

public A withPodTemplateList(PodTemplateList podTemplateList)

hasPodTemplateList
```
public boolean hasPodTemplateList()
```

withNewPodTemplateList

public ValidationSchemaFluent.PodTemplateListNested<A> withNewPodTemplateList()

withNewPodTemplateListLike

public ValidationSchemaFluent.PodTemplateListNested<A> withNewPodTemplateListLike(PodTemplateList item)

editPodTemplateList

public ValidationSchemaFluent.PodTemplateListNested<A> editPodTemplateList()

editOrNewPodTemplateList

public ValidationSchemaFluent.PodTemplateListNested<A> editOrNewPodTemplateList()

editOrNewPodTemplateListLike

public ValidationSchemaFluent.PodTemplateListNested<A> editOrNewPodTemplateListLike(PodTemplateList item)

buildQuantity
```
public Quantity buildQuantity()
```

withQuantity

public A withQuantity(Quantity quantity)

hasQuantity
```
public boolean hasQuantity()
```

withNewQuantity

public A withNewQuantity(String amount,
                         String format)

withNewQuantity

public A withNewQuantity(String amount)

withNewQuantity

public ValidationSchemaFluent.QuantityNested<A> withNewQuantity()

withNewQuantityLike

public ValidationSchemaFluent.QuantityNested<A> withNewQuantityLike(Quantity item)

editQuantity

public ValidationSchemaFluent.QuantityNested<A> editQuantity()

editOrNewQuantity

public ValidationSchemaFluent.QuantityNested<A> editOrNewQuantity()

editOrNewQuantityLike

public ValidationSchemaFluent.QuantityNested<A> editOrNewQuantityLike(Quantity item)

buildReplicationControllerList

public ReplicationControllerList buildReplicationControllerList()

withReplicationControllerList

public A withReplicationControllerList(ReplicationControllerList replicationControllerList)

hasReplicationControllerList

public boolean hasReplicationControllerList()

withNewReplicationControllerList

public ValidationSchemaFluent.ReplicationControllerListNested<A> withNewReplicationControllerList()

withNewReplicationControllerListLike

public ValidationSchemaFluent.ReplicationControllerListNested<A> withNewReplicationControllerListLike(ReplicationControllerList item)

editReplicationControllerList

public ValidationSchemaFluent.ReplicationControllerListNested<A> editReplicationControllerList()

editOrNewReplicationControllerList

public ValidationSchemaFluent.ReplicationControllerListNested<A> editOrNewReplicationControllerList()

editOrNewReplicationControllerListLike

public ValidationSchemaFluent.ReplicationControllerListNested<A> editOrNewReplicationControllerListLike(ReplicationControllerList item)

buildResourceQuota

public ResourceQuota buildResourceQuota()

withResourceQuota

public A withResourceQuota(ResourceQuota resourceQuota)

hasResourceQuota
```
public boolean hasResourceQuota()
```

withNewResourceQuota

public ValidationSchemaFluent.ResourceQuotaNested<A> withNewResourceQuota()

withNewResourceQuotaLike

public ValidationSchemaFluent.ResourceQuotaNested<A> withNewResourceQuotaLike(ResourceQuota item)

editResourceQuota

public ValidationSchemaFluent.ResourceQuotaNested<A> editResourceQuota()

editOrNewResourceQuota

public ValidationSchemaFluent.ResourceQuotaNested<A> editOrNewResourceQuota()

editOrNewResourceQuotaLike

public ValidationSchemaFluent.ResourceQuotaNested<A> editOrNewResourceQuotaLike(ResourceQuota item)

buildResourceQuotaList

public ResourceQuotaList buildResourceQuotaList()

withResourceQuotaList

public A withResourceQuotaList(ResourceQuotaList resourceQuotaList)

hasResourceQuotaList
```
public boolean hasResourceQuotaList()
```

withNewResourceQuotaList

public ValidationSchemaFluent.ResourceQuotaListNested<A> withNewResourceQuotaList()

withNewResourceQuotaListLike

public ValidationSchemaFluent.ResourceQuotaListNested<A> withNewResourceQuotaListLike(ResourceQuotaList item)

editResourceQuotaList

public ValidationSchemaFluent.ResourceQuotaListNested<A> editResourceQuotaList()

editOrNewResourceQuotaList

public ValidationSchemaFluent.ResourceQuotaListNested<A> editOrNewResourceQuotaList()

editOrNewResourceQuotaListLike

public ValidationSchemaFluent.ResourceQuotaListNested<A> editOrNewResourceQuotaListLike(ResourceQuotaList item)

buildRootPaths
```
public RootPaths buildRootPaths()
```

withRootPaths

public A withRootPaths(RootPaths rootPaths)

hasRootPaths
```
public boolean hasRootPaths()
```

withNewRootPaths

public ValidationSchemaFluent.RootPathsNested<A> withNewRootPaths()

withNewRootPathsLike

public ValidationSchemaFluent.RootPathsNested<A> withNewRootPathsLike(RootPaths item)

editRootPaths

public ValidationSchemaFluent.RootPathsNested<A> editRootPaths()

editOrNewRootPaths

public ValidationSchemaFluent.RootPathsNested<A> editOrNewRootPaths()

editOrNewRootPathsLike

public ValidationSchemaFluent.RootPathsNested<A> editOrNewRootPathsLike(RootPaths item)

buildSecret
```
public Secret buildSecret()
```

withSecret
```
public A withSecret(Secret secret)
```

hasSecret
```
public boolean hasSecret()
```

withNewSecret

public ValidationSchemaFluent.SecretNested<A> withNewSecret()

withNewSecretLike

public ValidationSchemaFluent.SecretNested<A> withNewSecretLike(Secret item)

editSecret

public ValidationSchemaFluent.SecretNested<A> editSecret()

editOrNewSecret

public ValidationSchemaFluent.SecretNested<A> editOrNewSecret()

editOrNewSecretLike

public ValidationSchemaFluent.SecretNested<A> editOrNewSecretLike(Secret item)

buildSecretList
```
public SecretList buildSecretList()
```

withSecretList

public A withSecretList(SecretList secretList)

hasSecretList
```
public boolean hasSecretList()
```

withNewSecretList

public ValidationSchemaFluent.SecretListNested<A> withNewSecretList()

withNewSecretListLike

public ValidationSchemaFluent.SecretListNested<A> withNewSecretListLike(SecretList item)

editSecretList

public ValidationSchemaFluent.SecretListNested<A> editSecretList()

editOrNewSecretList

public ValidationSchemaFluent.SecretListNested<A> editOrNewSecretList()

editOrNewSecretListLike

public ValidationSchemaFluent.SecretListNested<A> editOrNewSecretListLike(SecretList item)

buildServiceAccount

public ServiceAccount buildServiceAccount()

withServiceAccount

public A withServiceAccount(ServiceAccount serviceAccount)

hasServiceAccount
```
public boolean hasServiceAccount()
```

withNewServiceAccount

public ValidationSchemaFluent.ServiceAccountNested<A> withNewServiceAccount()

withNewServiceAccountLike

public ValidationSchemaFluent.ServiceAccountNested<A> withNewServiceAccountLike(ServiceAccount item)

editServiceAccount

public ValidationSchemaFluent.ServiceAccountNested<A> editServiceAccount()

editOrNewServiceAccount

public ValidationSchemaFluent.ServiceAccountNested<A> editOrNewServiceAccount()

editOrNewServiceAccountLike

public ValidationSchemaFluent.ServiceAccountNested<A> editOrNewServiceAccountLike(ServiceAccount item)

buildServiceAccountList

public ServiceAccountList buildServiceAccountList()

withServiceAccountList

public A withServiceAccountList(ServiceAccountList serviceAccountList)

hasServiceAccountList

public boolean hasServiceAccountList()

withNewServiceAccountList

public ValidationSchemaFluent.ServiceAccountListNested<A> withNewServiceAccountList()

withNewServiceAccountListLike

public ValidationSchemaFluent.ServiceAccountListNested<A> withNewServiceAccountListLike(ServiceAccountList item)

editServiceAccountList

public ValidationSchemaFluent.ServiceAccountListNested<A> editServiceAccountList()

editOrNewServiceAccountList

public ValidationSchemaFluent.ServiceAccountListNested<A> editOrNewServiceAccountList()

editOrNewServiceAccountListLike

public ValidationSchemaFluent.ServiceAccountListNested<A> editOrNewServiceAccountListLike(ServiceAccountList item)

buildServiceList
```
public ServiceList buildServiceList()
```

withServiceList

public A withServiceList(ServiceList serviceList)

hasServiceList
```
public boolean hasServiceList()
```

withNewServiceList

public ValidationSchemaFluent.ServiceListNested<A> withNewServiceList()

withNewServiceListLike

public ValidationSchemaFluent.ServiceListNested<A> withNewServiceListLike(ServiceList item)

editServiceList

public ValidationSchemaFluent.ServiceListNested<A> editServiceList()

editOrNewServiceList

public ValidationSchemaFluent.ServiceListNested<A> editOrNewServiceList()

editOrNewServiceListLike

public ValidationSchemaFluent.ServiceListNested<A> editOrNewServiceListLike(ServiceList item)

buildStatus
```
public Status buildStatus()
```

withStatus
```
public A withStatus(Status status)
```

hasStatus
```
public boolean hasStatus()
```

withNewStatus

public ValidationSchemaFluent.StatusNested<A> withNewStatus()

withNewStatusLike

public ValidationSchemaFluent.StatusNested<A> withNewStatusLike(Status item)

editStatus

public ValidationSchemaFluent.StatusNested<A> editStatus()

editOrNewStatus

public ValidationSchemaFluent.StatusNested<A> editOrNewStatus()

editOrNewStatusLike

public ValidationSchemaFluent.StatusNested<A> editOrNewStatusLike(Status item)

getTime
```
public String getTime()
```

withTime
```
public A withTime(String time)
```

hasTime
```
public boolean hasTime()
```

buildToleration
```
public Toleration buildToleration()
```

withToleration

public A withToleration(Toleration toleration)

hasToleration
```
public boolean hasToleration()
```

withNewToleration

public A withNewToleration(String effect,
                           String key,
                           String operator,
                           Long tolerationSeconds,
                           String value)

withNewToleration

public ValidationSchemaFluent.TolerationNested<A> withNewToleration()

withNewTolerationLike

public ValidationSchemaFluent.TolerationNested<A> withNewTolerationLike(Toleration item)

editToleration

public ValidationSchemaFluent.TolerationNested<A> editToleration()

editOrNewToleration

public ValidationSchemaFluent.TolerationNested<A> editOrNewToleration()

editOrNewTolerationLike

public ValidationSchemaFluent.TolerationNested<A> editOrNewTolerationLike(Toleration item)

buildTopologySelectorTerm

public TopologySelectorTerm buildTopologySelectorTerm()

withTopologySelectorTerm

public A withTopologySelectorTerm(TopologySelectorTerm topologySelectorTerm)

hasTopologySelectorTerm

public boolean hasTopologySelectorTerm()

withNewTopologySelectorTerm

public ValidationSchemaFluent.TopologySelectorTermNested<A> withNewTopologySelectorTerm()

withNewTopologySelectorTermLike

public ValidationSchemaFluent.TopologySelectorTermNested<A> withNewTopologySelectorTermLike(TopologySelectorTerm item)

editTopologySelectorTerm

public ValidationSchemaFluent.TopologySelectorTermNested<A> editTopologySelectorTerm()

editOrNewTopologySelectorTerm

public ValidationSchemaFluent.TopologySelectorTermNested<A> editOrNewTopologySelectorTerm()

editOrNewTopologySelectorTermLike

public ValidationSchemaFluent.TopologySelectorTermNested<A> editOrNewTopologySelectorTermLike(TopologySelectorTerm item)

buildTypeMeta
```
public TypeMeta buildTypeMeta()
```

withTypeMeta

public A withTypeMeta(TypeMeta typeMeta)

hasTypeMeta
```
public boolean hasTypeMeta()
```

withNewTypeMeta

public A withNewTypeMeta(String apiVersion,
                         String kind)

withNewTypeMeta

public ValidationSchemaFluent.TypeMetaNested<A> withNewTypeMeta()

withNewTypeMetaLike

public ValidationSchemaFluent.TypeMetaNested<A> withNewTypeMetaLike(TypeMeta item)

editTypeMeta

public ValidationSchemaFluent.TypeMetaNested<A> editTypeMeta()

editOrNewTypeMeta

public ValidationSchemaFluent.TypeMetaNested<A> editOrNewTypeMeta()

editOrNewTypeMetaLike

public ValidationSchemaFluent.TypeMetaNested<A> editOrNewTypeMetaLike(TypeMeta item)

buildUpdateOptions

public UpdateOptions buildUpdateOptions()

withUpdateOptions

public A withUpdateOptions(UpdateOptions updateOptions)

hasUpdateOptions
```
public boolean hasUpdateOptions()
```

withNewUpdateOptions

public ValidationSchemaFluent.UpdateOptionsNested<A> withNewUpdateOptions()

withNewUpdateOptionsLike

public ValidationSchemaFluent.UpdateOptionsNested<A> withNewUpdateOptionsLike(UpdateOptions item)

editUpdateOptions

public ValidationSchemaFluent.UpdateOptionsNested<A> editUpdateOptions()

editOrNewUpdateOptions

public ValidationSchemaFluent.UpdateOptionsNested<A> editOrNewUpdateOptions()

editOrNewUpdateOptionsLike

public ValidationSchemaFluent.UpdateOptionsNested<A> editOrNewUpdateOptionsLike(UpdateOptions item)

buildWatchEvent
```
public WatchEvent buildWatchEvent()
```

withWatchEvent

public A withWatchEvent(WatchEvent watchEvent)

hasWatchEvent
```
public boolean hasWatchEvent()
```

withNewWatchEvent

public ValidationSchemaFluent.WatchEventNested<A> withNewWatchEvent()

withNewWatchEventLike

public ValidationSchemaFluent.WatchEventNested<A> withNewWatchEventLike(WatchEvent item)

editWatchEvent

public ValidationSchemaFluent.WatchEventNested<A> editWatchEvent()

editOrNewWatchEvent

public ValidationSchemaFluent.WatchEventNested<A> editOrNewWatchEvent()

editOrNewWatchEventLike

public ValidationSchemaFluent.WatchEventNested<A> editOrNewWatchEventLike(WatchEvent item)

addToAdditionalProperties

public A addToAdditionalProperties(String key,
                                   Object value)

addToAdditionalProperties

public A addToAdditionalProperties(Map<String,Object> map)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(String key)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(Map<String,Object> map)

getAdditionalProperties

public Map<String,Object> getAdditionalProperties()

withAdditionalProperties

public <K,V> A withAdditionalProperties(Map<String,Object> additionalProperties)

hasAdditionalProperties

public boolean hasAdditionalProperties()

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class BaseFluent<A extends ValidationSchemaFluent<A>>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class BaseFluent<A extends ValidationSchemaFluent<A>>

toString
```
public String toString()
```
Overrides:

toString in class Object

Class ValidationSchemaFluent<A extends ValidationSchemaFluent<A>>

Nested Class Summary

Field Summary

Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Methods inherited from class java.lang.Object

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable

Constructor Detail

ValidationSchemaFluent

ValidationSchemaFluent

Method Detail

buildAPIGroup

withAPIGroup

hasAPIGroup

withNewAPIGroup

withNewAPIGroupLike

editAPIGroup

editOrNewAPIGroup

editOrNewAPIGroupLike

buildAPIGroupList

withAPIGroupList

hasAPIGroupList

withNewAPIGroupList

withNewAPIGroupListLike

editAPIGroupList

editOrNewAPIGroupList

editOrNewAPIGroupListLike

buildAPIResource

withAPIResource

hasAPIResource

withNewAPIResource

withNewAPIResourceLike

editAPIResource

editOrNewAPIResource

editOrNewAPIResourceLike

buildAPIResourceList

withAPIResourceList

hasAPIResourceList

withNewAPIResourceList

withNewAPIResourceListLike

editAPIResourceList

editOrNewAPIResourceList

editOrNewAPIResourceListLike

buildAPIService

withAPIService

hasAPIService

withNewAPIService

withNewAPIServiceLike

editAPIService

editOrNewAPIService

editOrNewAPIServiceLike

buildAPIServiceList

withAPIServiceList

hasAPIServiceList

withNewAPIServiceList

withNewAPIServiceListLike

editAPIServiceList

editOrNewAPIServiceList

editOrNewAPIServiceListLike

buildBinding

withBinding

hasBinding

withNewBinding

withNewBindingLike

editBinding

editOrNewBinding

editOrNewBindingLike

buildComponentStatus

withComponentStatus

hasComponentStatus

withNewComponentStatus

withNewComponentStatusLike

editComponentStatus

editOrNewComponentStatus

editOrNewComponentStatusLike

buildComponentStatusList

withComponentStatusList

hasComponentStatusList