java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.apicurio.registry.operator.api.v1.model.apicurioregistryspec.deployment.podtemplatespecpreview.SpecFluent<A>

All Implemented Interfaces:

io.fabric8.kubernetes.api.builder.Fluent<A>, io.fabric8.kubernetes.api.builder.Visitable<A>

Direct Known Subclasses:

PodTemplateSpecPreviewFluent.SpecNested, SpecBuilder
```
public class SpecFluent<A extends SpecFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`SpecFluent.ContainersNested<N>`
`class`	`SpecFluent.DnsConfigNested<N>`
`class`	`SpecFluent.EphemeralContainersNested<N>`
`class`	`SpecFluent.HostAliasesNested<N>`
`class`	`SpecFluent.InitContainersNested<N>`
`class`	`SpecFluent.OsNested<N>`
`class`	`SpecFluent.ReadinessGatesNested<N>`
`class`	`SpecFluent.SecurityContextNested<N>`
`class`	`SpecFluent.SpecAffinityNested<N>`
`class`	`SpecFluent.SpecImagePullSecretsNested<N>`
`class`	`SpecFluent.SpecTolerationsNested<N>`
`class`	`SpecFluent.TopologySpreadConstraintsNested<N>`
`class`	`SpecFluent.VolumesNested<N>`

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

Constructor Summary

Constructors
Constructor Description

SpecFluent()

SpecFluent(Spec instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToContainers(Collection<Containers> items)`
`A`	`addAllToEphemeralContainers(Collection<EphemeralContainers> items)`
`A`	`addAllToHostAliases(Collection<HostAliases> items)`
`A`	`addAllToInitContainers(Collection<InitContainers> items)`
`A`	`addAllToReadinessGates(Collection<ReadinessGates> items)`
`A`	`addAllToSpecImagePullSecrets(Collection<ImagePullSecrets> items)`
`A`	`addAllToSpecTolerations(Collection<Tolerations> items)`
`A`	`addAllToTopologySpreadConstraints(Collection<TopologySpreadConstraints> items)`
`A`	`addAllToVolumes(Collection<Volumes> items)`
`SpecFluent.ContainersNested<A>`	`addNewContainer()`
`SpecFluent.ContainersNested<A>`	`addNewContainerLike(Containers item)`
`SpecFluent.EphemeralContainersNested<A>`	`addNewEphemeralContainer()`
`SpecFluent.EphemeralContainersNested<A>`	`addNewEphemeralContainerLike(EphemeralContainers item)`
`SpecFluent.HostAliasesNested<A>`	`addNewHostAlias()`
`SpecFluent.HostAliasesNested<A>`	`addNewHostAliasLike(HostAliases item)`
`SpecFluent.SpecImagePullSecretsNested<A>`	`addNewImagePullSecretLike(ImagePullSecrets item)`
`SpecFluent.InitContainersNested<A>`	`addNewInitContainer()`
`SpecFluent.InitContainersNested<A>`	`addNewInitContainerLike(InitContainers item)`
`SpecFluent.ReadinessGatesNested<A>`	`addNewReadinessGate()`
`SpecFluent.ReadinessGatesNested<A>`	`addNewReadinessGateLike(ReadinessGates item)`
`SpecFluent.SpecImagePullSecretsNested<A>`	`addNewSpecImagePullSecret()`
`SpecFluent.SpecTolerationsNested<A>`	`addNewSpecToleration()`
`SpecFluent.SpecTolerationsNested<A>`	`addNewTolerationLike(Tolerations item)`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`addNewTopologySpreadConstraint()`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`addNewTopologySpreadConstraintLike(TopologySpreadConstraints item)`
`SpecFluent.VolumesNested<A>`	`addNewVolume()`
`SpecFluent.VolumesNested<A>`	`addNewVolumeLike(Volumes item)`
`A`	`addToContainers(int index, Containers item)`
`A`	`addToContainers(Containers... items)`
`A`	`addToEphemeralContainers(int index, EphemeralContainers item)`
`A`	`addToEphemeralContainers(EphemeralContainers... items)`
`A`	`addToHostAliases(int index, HostAliases item)`
`A`	`addToHostAliases(HostAliases... items)`
`A`	`addToImagePullSecrets(int index, ImagePullSecrets item)`
`A`	`addToImagePullSecrets(ImagePullSecrets... items)`
`A`	`addToInitContainers(int index, InitContainers item)`
`A`	`addToInitContainers(InitContainers... items)`
`A`	`addToNodeSelector(String key, String value)`
`A`	`addToNodeSelector(Map<String,String> map)`
`A`	`addToOverhead(String key, io.fabric8.kubernetes.api.model.IntOrString value)`
`A`	`addToOverhead(Map<String,io.fabric8.kubernetes.api.model.IntOrString> map)`
`A`	`addToReadinessGates(int index, ReadinessGates item)`
`A`	`addToReadinessGates(ReadinessGates... items)`
`A`	`addToTolerations(int index, Tolerations item)`
`A`	`addToTolerations(Tolerations... items)`
`A`	`addToTopologySpreadConstraints(int index, TopologySpreadConstraints item)`
`A`	`addToTopologySpreadConstraints(TopologySpreadConstraints... items)`
`A`	`addToVolumes(int index, Volumes item)`
`A`	`addToVolumes(Volumes... items)`
`Affinity`	`buildAffinity()`
`Containers`	`buildContainer(int index)`
`List<Containers>`	`buildContainers()`
`DnsConfig`	`buildDnsConfig()`
`EphemeralContainers`	`buildEphemeralContainer(int index)`
`List<EphemeralContainers>`	`buildEphemeralContainers()`
`Containers`	`buildFirstContainer()`
`EphemeralContainers`	`buildFirstEphemeralContainer()`
`HostAliases`	`buildFirstHostAlias()`
`ImagePullSecrets`	`buildFirstImagePullSecret()`
`InitContainers`	`buildFirstInitContainer()`
`ReadinessGates`	`buildFirstReadinessGate()`
`Tolerations`	`buildFirstToleration()`
`TopologySpreadConstraints`	`buildFirstTopologySpreadConstraint()`
`Volumes`	`buildFirstVolume()`
`HostAliases`	`buildHostAlias(int index)`
`List<HostAliases>`	`buildHostAliases()`
`ImagePullSecrets`	`buildImagePullSecret(int index)`
`List<ImagePullSecrets>`	`buildImagePullSecrets()`
`InitContainers`	`buildInitContainer(int index)`
`List<InitContainers>`	`buildInitContainers()`
`Containers`	`buildLastContainer()`
`EphemeralContainers`	`buildLastEphemeralContainer()`
`HostAliases`	`buildLastHostAlias()`
`ImagePullSecrets`	`buildLastImagePullSecret()`
`InitContainers`	`buildLastInitContainer()`
`ReadinessGates`	`buildLastReadinessGate()`
`Tolerations`	`buildLastToleration()`
`TopologySpreadConstraints`	`buildLastTopologySpreadConstraint()`
`Volumes`	`buildLastVolume()`
`Containers`	`buildMatchingContainer(Predicate<ContainersBuilder> predicate)`
`EphemeralContainers`	`buildMatchingEphemeralContainer(Predicate<EphemeralContainersBuilder> predicate)`
`HostAliases`	`buildMatchingHostAlias(Predicate<HostAliasesBuilder> predicate)`
`ImagePullSecrets`	`buildMatchingImagePullSecret(Predicate<ImagePullSecretsBuilder> predicate)`
`InitContainers`	`buildMatchingInitContainer(Predicate<InitContainersBuilder> predicate)`
`ReadinessGates`	`buildMatchingReadinessGate(Predicate<ReadinessGatesBuilder> predicate)`
`Tolerations`	`buildMatchingToleration(Predicate<TolerationsBuilder> predicate)`
`TopologySpreadConstraints`	`buildMatchingTopologySpreadConstraint(Predicate<TopologySpreadConstraintsBuilder> predicate)`
`Volumes`	`buildMatchingVolume(Predicate<VolumesBuilder> predicate)`
`Os`	`buildOs()`
`ReadinessGates`	`buildReadinessGate(int index)`
`List<ReadinessGates>`	`buildReadinessGates()`
`SecurityContext`	`buildSecurityContext()`
`Tolerations`	`buildToleration(int index)`
`List<Tolerations>`	`buildTolerations()`
`TopologySpreadConstraints`	`buildTopologySpreadConstraint(int index)`
`List<TopologySpreadConstraints>`	`buildTopologySpreadConstraints()`
`Volumes`	`buildVolume(int index)`
`List<Volumes>`	`buildVolumes()`
`SpecFluent.ContainersNested<A>`	`editContainer(int index)`
`SpecFluent.DnsConfigNested<A>`	`editDnsConfig()`
`SpecFluent.EphemeralContainersNested<A>`	`editEphemeralContainer(int index)`
`SpecFluent.ContainersNested<A>`	`editFirstContainer()`
`SpecFluent.EphemeralContainersNested<A>`	`editFirstEphemeralContainer()`
`SpecFluent.HostAliasesNested<A>`	`editFirstHostAlias()`
`SpecFluent.SpecImagePullSecretsNested<A>`	`editFirstImagePullSecret()`
`SpecFluent.InitContainersNested<A>`	`editFirstInitContainer()`
`SpecFluent.ReadinessGatesNested<A>`	`editFirstReadinessGate()`
`SpecFluent.SpecTolerationsNested<A>`	`editFirstToleration()`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`editFirstTopologySpreadConstraint()`
`SpecFluent.VolumesNested<A>`	`editFirstVolume()`
`SpecFluent.HostAliasesNested<A>`	`editHostAlias(int index)`
`SpecFluent.SpecImagePullSecretsNested<A>`	`editImagePullSecret(int index)`
`SpecFluent.InitContainersNested<A>`	`editInitContainer(int index)`
`SpecFluent.ContainersNested<A>`	`editLastContainer()`
`SpecFluent.EphemeralContainersNested<A>`	`editLastEphemeralContainer()`
`SpecFluent.HostAliasesNested<A>`	`editLastHostAlias()`
`SpecFluent.SpecImagePullSecretsNested<A>`	`editLastImagePullSecret()`
`SpecFluent.InitContainersNested<A>`	`editLastInitContainer()`
`SpecFluent.ReadinessGatesNested<A>`	`editLastReadinessGate()`
`SpecFluent.SpecTolerationsNested<A>`	`editLastToleration()`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`editLastTopologySpreadConstraint()`
`SpecFluent.VolumesNested<A>`	`editLastVolume()`
`SpecFluent.ContainersNested<A>`	`editMatchingContainer(Predicate<ContainersBuilder> predicate)`
`SpecFluent.EphemeralContainersNested<A>`	`editMatchingEphemeralContainer(Predicate<EphemeralContainersBuilder> predicate)`
`SpecFluent.HostAliasesNested<A>`	`editMatchingHostAlias(Predicate<HostAliasesBuilder> predicate)`
`SpecFluent.SpecImagePullSecretsNested<A>`	`editMatchingImagePullSecret(Predicate<ImagePullSecretsBuilder> predicate)`
`SpecFluent.InitContainersNested<A>`	`editMatchingInitContainer(Predicate<InitContainersBuilder> predicate)`
`SpecFluent.ReadinessGatesNested<A>`	`editMatchingReadinessGate(Predicate<ReadinessGatesBuilder> predicate)`
`SpecFluent.SpecTolerationsNested<A>`	`editMatchingToleration(Predicate<TolerationsBuilder> predicate)`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`editMatchingTopologySpreadConstraint(Predicate<TopologySpreadConstraintsBuilder> predicate)`
`SpecFluent.VolumesNested<A>`	`editMatchingVolume(Predicate<VolumesBuilder> predicate)`
`SpecFluent.SpecAffinityNested<A>`	`editOrNewAffinity()`
`SpecFluent.SpecAffinityNested<A>`	`editOrNewAffinityLike(Affinity item)`
`SpecFluent.DnsConfigNested<A>`	`editOrNewDnsConfig()`
`SpecFluent.DnsConfigNested<A>`	`editOrNewDnsConfigLike(DnsConfig item)`
`SpecFluent.OsNested<A>`	`editOrNewOs()`
`SpecFluent.OsNested<A>`	`editOrNewOsLike(Os item)`
`SpecFluent.SecurityContextNested<A>`	`editOrNewSecurityContext()`
`SpecFluent.SecurityContextNested<A>`	`editOrNewSecurityContextLike(SecurityContext item)`
`SpecFluent.OsNested<A>`	`editOs()`
`SpecFluent.ReadinessGatesNested<A>`	`editReadinessGate(int index)`
`SpecFluent.SecurityContextNested<A>`	`editSecurityContext()`
`SpecFluent.SpecAffinityNested<A>`	`editSpecAffinity()`
`SpecFluent.SpecTolerationsNested<A>`	`editToleration(int index)`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`editTopologySpreadConstraint(int index)`
`SpecFluent.VolumesNested<A>`	`editVolume(int index)`
`boolean`	`equals(Object o)`
`Long`	`getActiveDeadlineSeconds()`
`Boolean`	`getAutomountServiceAccountToken()`
`String`	`getDnsPolicy()`
`Boolean`	`getEnableServiceLinks()`
`Boolean`	`getHostIPC()`
`String`	`getHostname()`
`Boolean`	`getHostNetwork()`
`Boolean`	`getHostPID()`
`String`	`getNodeName()`
`Map<String,String>`	`getNodeSelector()`
`Map<String,io.fabric8.kubernetes.api.model.IntOrString>`	`getOverhead()`
`String`	`getPreemptionPolicy()`
`Integer`	`getPriority()`
`String`	`getPriorityClassName()`
`String`	`getRestartPolicy()`
`String`	`getRuntimeClassName()`
`String`	`getSchedulerName()`
`String`	`getServiceAccount()`
`String`	`getServiceAccountName()`
`Boolean`	`getSetHostnameAsFQDN()`
`Boolean`	`getShareProcessNamespace()`
`String`	`getSubdomain()`
`Long`	`getTerminationGracePeriodSeconds()`
`boolean`	`hasActiveDeadlineSeconds()`
`boolean`	`hasAffinity()`
`boolean`	`hasAutomountServiceAccountToken()`
`boolean`	`hasContainers()`
`boolean`	`hasDnsConfig()`
`boolean`	`hasDnsPolicy()`
`boolean`	`hasEnableServiceLinks()`
`boolean`	`hasEphemeralContainers()`
`int`	`hashCode()`
`boolean`	`hasHostAliases()`
`boolean`	`hasHostIPC()`
`boolean`	`hasHostname()`
`boolean`	`hasHostNetwork()`
`boolean`	`hasHostPID()`
`boolean`	`hasImagePullSecrets()`
`boolean`	`hasInitContainers()`
`boolean`	`hasMatchingContainer(Predicate<ContainersBuilder> predicate)`
`boolean`	`hasMatchingEphemeralContainer(Predicate<EphemeralContainersBuilder> predicate)`
`boolean`	`hasMatchingHostAlias(Predicate<HostAliasesBuilder> predicate)`
`boolean`	`hasMatchingImagePullSecret(Predicate<ImagePullSecretsBuilder> predicate)`
`boolean`	`hasMatchingInitContainer(Predicate<InitContainersBuilder> predicate)`
`boolean`	`hasMatchingReadinessGate(Predicate<ReadinessGatesBuilder> predicate)`
`boolean`	`hasMatchingToleration(Predicate<TolerationsBuilder> predicate)`
`boolean`	`hasMatchingTopologySpreadConstraint(Predicate<TopologySpreadConstraintsBuilder> predicate)`
`boolean`	`hasMatchingVolume(Predicate<VolumesBuilder> predicate)`
`boolean`	`hasNodeName()`
`boolean`	`hasNodeSelector()`
`boolean`	`hasOs()`
`boolean`	`hasOverhead()`
`boolean`	`hasPreemptionPolicy()`
`boolean`	`hasPriority()`
`boolean`	`hasPriorityClassName()`
`boolean`	`hasReadinessGates()`
`boolean`	`hasRestartPolicy()`
`boolean`	`hasRuntimeClassName()`
`boolean`	`hasSchedulerName()`
`boolean`	`hasSecurityContext()`
`boolean`	`hasServiceAccount()`
`boolean`	`hasServiceAccountName()`
`boolean`	`hasSetHostnameAsFQDN()`
`boolean`	`hasShareProcessNamespace()`
`boolean`	`hasSubdomain()`
`boolean`	`hasTerminationGracePeriodSeconds()`
`boolean`	`hasTolerations()`
`boolean`	`hasTopologySpreadConstraints()`
`boolean`	`hasVolumes()`
`A`	`removeAllFromContainers(Collection<Containers> items)`
`A`	`removeAllFromEphemeralContainers(Collection<EphemeralContainers> items)`
`A`	`removeAllFromHostAliases(Collection<HostAliases> items)`
`A`	`removeAllFromInitContainers(Collection<InitContainers> items)`
`A`	`removeAllFromReadinessGates(Collection<ReadinessGates> items)`
`A`	`removeAllFromSpecImagePullSecrets(Collection<ImagePullSecrets> items)`
`A`	`removeAllFromSpecTolerations(Collection<Tolerations> items)`
`A`	`removeAllFromTopologySpreadConstraints(Collection<TopologySpreadConstraints> items)`
`A`	`removeAllFromVolumes(Collection<Volumes> items)`
`A`	`removeFromContainers(Containers... items)`
`A`	`removeFromEphemeralContainers(EphemeralContainers... items)`
`A`	`removeFromHostAliases(HostAliases... items)`
`A`	`removeFromImagePullSecrets(ImagePullSecrets... items)`
`A`	`removeFromInitContainers(InitContainers... items)`
`A`	`removeFromNodeSelector(String key)`
`A`	`removeFromNodeSelector(Map<String,String> map)`
`A`	`removeFromOverhead(String key)`
`A`	`removeFromOverhead(Map<String,io.fabric8.kubernetes.api.model.IntOrString> map)`
`A`	`removeFromReadinessGates(ReadinessGates... items)`
`A`	`removeFromTolerations(Tolerations... items)`
`A`	`removeFromTopologySpreadConstraints(TopologySpreadConstraints... items)`
`A`	`removeFromVolumes(Volumes... items)`
`A`	`removeMatchingFromContainers(Predicate<ContainersBuilder> predicate)`
`A`	`removeMatchingFromEphemeralContainers(Predicate<EphemeralContainersBuilder> predicate)`
`A`	`removeMatchingFromHostAliases(Predicate<HostAliasesBuilder> predicate)`
`A`	`removeMatchingFromInitContainers(Predicate<InitContainersBuilder> predicate)`
`A`	`removeMatchingFromReadinessGates(Predicate<ReadinessGatesBuilder> predicate)`
`A`	`removeMatchingFromSpecImagePullSecrets(Predicate<ImagePullSecretsBuilder> predicate)`
`A`	`removeMatchingFromSpecTolerations(Predicate<TolerationsBuilder> predicate)`
`A`	`removeMatchingFromTopologySpreadConstraints(Predicate<TopologySpreadConstraintsBuilder> predicate)`
`A`	`removeMatchingFromVolumes(Predicate<VolumesBuilder> predicate)`
`SpecFluent.ContainersNested<A>`	`setNewContainerLike(int index, Containers item)`
`SpecFluent.EphemeralContainersNested<A>`	`setNewEphemeralContainerLike(int index, EphemeralContainers item)`
`SpecFluent.HostAliasesNested<A>`	`setNewHostAliasLike(int index, HostAliases item)`
`SpecFluent.SpecImagePullSecretsNested<A>`	`setNewImagePullSecretLike(int index, ImagePullSecrets item)`
`SpecFluent.InitContainersNested<A>`	`setNewInitContainerLike(int index, InitContainers item)`
`SpecFluent.ReadinessGatesNested<A>`	`setNewReadinessGateLike(int index, ReadinessGates item)`
`SpecFluent.SpecTolerationsNested<A>`	`setNewTolerationLike(int index, Tolerations item)`
`SpecFluent.TopologySpreadConstraintsNested<A>`	`setNewTopologySpreadConstraintLike(int index, TopologySpreadConstraints item)`
`SpecFluent.VolumesNested<A>`	`setNewVolumeLike(int index, Volumes item)`
`A`	`setToContainers(int index, Containers item)`
`A`	`setToEphemeralContainers(int index, EphemeralContainers item)`
`A`	`setToHostAliases(int index, HostAliases item)`
`A`	`setToImagePullSecrets(int index, ImagePullSecrets item)`
`A`	`setToInitContainers(int index, InitContainers item)`
`A`	`setToReadinessGates(int index, ReadinessGates item)`
`A`	`setToTolerations(int index, Tolerations item)`
`A`	`setToTopologySpreadConstraints(int index, TopologySpreadConstraints item)`
`A`	`setToVolumes(int index, Volumes item)`
`String`	`toString()`
`A`	`withActiveDeadlineSeconds(Long activeDeadlineSeconds)`
`A`	`withAffinity(Affinity affinity)`
`A`	`withAutomountServiceAccountToken()`
`A`	`withAutomountServiceAccountToken(Boolean automountServiceAccountToken)`
`A`	`withContainers(Containers... containers)`
`A`	`withContainers(List<Containers> containers)`
`A`	`withDnsConfig(DnsConfig dnsConfig)`
`A`	`withDnsPolicy(String dnsPolicy)`
`A`	`withEnableServiceLinks()`
`A`	`withEnableServiceLinks(Boolean enableServiceLinks)`
`A`	`withEphemeralContainers(EphemeralContainers... ephemeralContainers)`
`A`	`withEphemeralContainers(List<EphemeralContainers> ephemeralContainers)`
`A`	`withHostAliases(HostAliases... hostAliases)`
`A`	`withHostAliases(List<HostAliases> hostAliases)`
`A`	`withHostIPC()`
`A`	`withHostIPC(Boolean hostIPC)`
`A`	`withHostname(String hostname)`
`A`	`withHostNetwork()`
`A`	`withHostNetwork(Boolean hostNetwork)`
`A`	`withHostPID()`
`A`	`withHostPID(Boolean hostPID)`
`A`	`withImagePullSecrets(ImagePullSecrets... imagePullSecrets)`
`A`	`withImagePullSecrets(List<ImagePullSecrets> imagePullSecrets)`
`A`	`withInitContainers(InitContainers... initContainers)`
`A`	`withInitContainers(List<InitContainers> initContainers)`
`SpecFluent.SpecAffinityNested<A>`	`withNewAffinityLike(Affinity item)`
`SpecFluent.DnsConfigNested<A>`	`withNewDnsConfig()`
`SpecFluent.DnsConfigNested<A>`	`withNewDnsConfigLike(DnsConfig item)`
`SpecFluent.OsNested<A>`	`withNewOs()`
`SpecFluent.OsNested<A>`	`withNewOsLike(Os item)`
`SpecFluent.SecurityContextNested<A>`	`withNewSecurityContext()`
`SpecFluent.SecurityContextNested<A>`	`withNewSecurityContextLike(SecurityContext item)`
`SpecFluent.SpecAffinityNested<A>`	`withNewSpecAffinity()`
`A`	`withNodeName(String nodeName)`
`<K,V> A`	`withNodeSelector(Map<String,String> nodeSelector)`
`A`	`withOs(Os os)`
`<K,V> A`	`withOverhead(Map<String,io.fabric8.kubernetes.api.model.IntOrString> overhead)`
`A`	`withPreemptionPolicy(String preemptionPolicy)`
`A`	`withPriority(Integer priority)`
`A`	`withPriorityClassName(String priorityClassName)`
`A`	`withReadinessGates(ReadinessGates... readinessGates)`
`A`	`withReadinessGates(List<ReadinessGates> readinessGates)`
`A`	`withRestartPolicy(String restartPolicy)`
`A`	`withRuntimeClassName(String runtimeClassName)`
`A`	`withSchedulerName(String schedulerName)`
`A`	`withSecurityContext(SecurityContext securityContext)`
`A`	`withServiceAccount(String serviceAccount)`
`A`	`withServiceAccountName(String serviceAccountName)`
`A`	`withSetHostnameAsFQDN()`
`A`	`withSetHostnameAsFQDN(Boolean setHostnameAsFQDN)`
`A`	`withShareProcessNamespace()`
`A`	`withShareProcessNamespace(Boolean shareProcessNamespace)`
`A`	`withSubdomain(String subdomain)`
`A`	`withTerminationGracePeriodSeconds(Long terminationGracePeriodSeconds)`
`A`	`withTolerations(Tolerations... tolerations)`
`A`	`withTolerations(List<Tolerations> tolerations)`
`A`	`withTopologySpreadConstraints(TopologySpreadConstraints... topologySpreadConstraints)`
`A`	`withTopologySpreadConstraints(List<TopologySpreadConstraints> topologySpreadConstraints)`
`A`	`withVolumes(Volumes... volumes)`
`A`	`withVolumes(List<Volumes> volumes)`

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

SpecFluent
```
public SpecFluent()
```

SpecFluent
```
public SpecFluent(Spec instance)
```

Method Detail

getActiveDeadlineSeconds

public Long getActiveDeadlineSeconds()

withActiveDeadlineSeconds

public A withActiveDeadlineSeconds(Long activeDeadlineSeconds)

hasActiveDeadlineSeconds

public boolean hasActiveDeadlineSeconds()

buildAffinity
```
public Affinity buildAffinity()
```

withAffinity

public A withAffinity(Affinity affinity)

hasAffinity
```
public boolean hasAffinity()
```

withNewSpecAffinity

public SpecFluent.SpecAffinityNested<A> withNewSpecAffinity()

withNewAffinityLike

public SpecFluent.SpecAffinityNested<A> withNewAffinityLike(Affinity item)

editSpecAffinity

public SpecFluent.SpecAffinityNested<A> editSpecAffinity()

editOrNewAffinity

public SpecFluent.SpecAffinityNested<A> editOrNewAffinity()

editOrNewAffinityLike

public SpecFluent.SpecAffinityNested<A> editOrNewAffinityLike(Affinity item)

getAutomountServiceAccountToken

public Boolean getAutomountServiceAccountToken()

withAutomountServiceAccountToken

public A withAutomountServiceAccountToken(Boolean automountServiceAccountToken)

hasAutomountServiceAccountToken

public boolean hasAutomountServiceAccountToken()

addToContainers

public A addToContainers(int index,
                         Containers item)

setToContainers

public A setToContainers(int index,
                         Containers item)

addToContainers

public A addToContainers(Containers... items)

addAllToContainers

public A addAllToContainers(Collection<Containers> items)

removeFromContainers

public A removeFromContainers(Containers... items)

removeAllFromContainers

public A removeAllFromContainers(Collection<Containers> items)

removeMatchingFromContainers

public A removeMatchingFromContainers(Predicate<ContainersBuilder> predicate)

buildContainers

public List<Containers> buildContainers()

buildContainer

public Containers buildContainer(int index)

buildFirstContainer

public Containers buildFirstContainer()

buildLastContainer

public Containers buildLastContainer()

buildMatchingContainer

public Containers buildMatchingContainer(Predicate<ContainersBuilder> predicate)

hasMatchingContainer

public boolean hasMatchingContainer(Predicate<ContainersBuilder> predicate)

withContainers

public A withContainers(List<Containers> containers)

withContainers

public A withContainers(Containers... containers)

hasContainers
```
public boolean hasContainers()
```

addNewContainer

public SpecFluent.ContainersNested<A> addNewContainer()

addNewContainerLike

public SpecFluent.ContainersNested<A> addNewContainerLike(Containers item)

setNewContainerLike

public SpecFluent.ContainersNested<A> setNewContainerLike(int index,
                                                          Containers item)

editContainer

public SpecFluent.ContainersNested<A> editContainer(int index)

editFirstContainer

public SpecFluent.ContainersNested<A> editFirstContainer()

editLastContainer

public SpecFluent.ContainersNested<A> editLastContainer()

editMatchingContainer

public SpecFluent.ContainersNested<A> editMatchingContainer(Predicate<ContainersBuilder> predicate)

buildDnsConfig
```
public DnsConfig buildDnsConfig()
```

withDnsConfig

public A withDnsConfig(DnsConfig dnsConfig)

hasDnsConfig
```
public boolean hasDnsConfig()
```

withNewDnsConfig

public SpecFluent.DnsConfigNested<A> withNewDnsConfig()

withNewDnsConfigLike

public SpecFluent.DnsConfigNested<A> withNewDnsConfigLike(DnsConfig item)

editDnsConfig

public SpecFluent.DnsConfigNested<A> editDnsConfig()

editOrNewDnsConfig

public SpecFluent.DnsConfigNested<A> editOrNewDnsConfig()

editOrNewDnsConfigLike

public SpecFluent.DnsConfigNested<A> editOrNewDnsConfigLike(DnsConfig item)

getDnsPolicy
```
public String getDnsPolicy()
```

withDnsPolicy

public A withDnsPolicy(String dnsPolicy)

hasDnsPolicy
```
public boolean hasDnsPolicy()
```

getEnableServiceLinks

public Boolean getEnableServiceLinks()

withEnableServiceLinks

public A withEnableServiceLinks(Boolean enableServiceLinks)

hasEnableServiceLinks

public boolean hasEnableServiceLinks()

addToEphemeralContainers

public A addToEphemeralContainers(int index,
                                  EphemeralContainers item)

setToEphemeralContainers

public A setToEphemeralContainers(int index,
                                  EphemeralContainers item)

addToEphemeralContainers

public A addToEphemeralContainers(EphemeralContainers... items)

addAllToEphemeralContainers

public A addAllToEphemeralContainers(Collection<EphemeralContainers> items)

removeFromEphemeralContainers

public A removeFromEphemeralContainers(EphemeralContainers... items)

removeAllFromEphemeralContainers

public A removeAllFromEphemeralContainers(Collection<EphemeralContainers> items)

removeMatchingFromEphemeralContainers

public A removeMatchingFromEphemeralContainers(Predicate<EphemeralContainersBuilder> predicate)

buildEphemeralContainers

public List<EphemeralContainers> buildEphemeralContainers()

buildEphemeralContainer

public EphemeralContainers buildEphemeralContainer(int index)

buildFirstEphemeralContainer

public EphemeralContainers buildFirstEphemeralContainer()

buildLastEphemeralContainer

public EphemeralContainers buildLastEphemeralContainer()

buildMatchingEphemeralContainer

public EphemeralContainers buildMatchingEphemeralContainer(Predicate<EphemeralContainersBuilder> predicate)

hasMatchingEphemeralContainer

public boolean hasMatchingEphemeralContainer(Predicate<EphemeralContainersBuilder> predicate)

withEphemeralContainers

public A withEphemeralContainers(List<EphemeralContainers> ephemeralContainers)

withEphemeralContainers

public A withEphemeralContainers(EphemeralContainers... ephemeralContainers)

hasEphemeralContainers

public boolean hasEphemeralContainers()

addNewEphemeralContainer

public SpecFluent.EphemeralContainersNested<A> addNewEphemeralContainer()

addNewEphemeralContainerLike

public SpecFluent.EphemeralContainersNested<A> addNewEphemeralContainerLike(EphemeralContainers item)

setNewEphemeralContainerLike

public SpecFluent.EphemeralContainersNested<A> setNewEphemeralContainerLike(int index,
                                                                            EphemeralContainers item)

editEphemeralContainer

public SpecFluent.EphemeralContainersNested<A> editEphemeralContainer(int index)

editFirstEphemeralContainer

public SpecFluent.EphemeralContainersNested<A> editFirstEphemeralContainer()

editLastEphemeralContainer

public SpecFluent.EphemeralContainersNested<A> editLastEphemeralContainer()

editMatchingEphemeralContainer

public SpecFluent.EphemeralContainersNested<A> editMatchingEphemeralContainer(Predicate<EphemeralContainersBuilder> predicate)

addToHostAliases

public A addToHostAliases(int index,
                          HostAliases item)

setToHostAliases

public A setToHostAliases(int index,
                          HostAliases item)

addToHostAliases

public A addToHostAliases(HostAliases... items)

addAllToHostAliases

public A addAllToHostAliases(Collection<HostAliases> items)

removeFromHostAliases

public A removeFromHostAliases(HostAliases... items)

removeAllFromHostAliases

public A removeAllFromHostAliases(Collection<HostAliases> items)

removeMatchingFromHostAliases

public A removeMatchingFromHostAliases(Predicate<HostAliasesBuilder> predicate)

buildHostAliases

public List<HostAliases> buildHostAliases()

buildHostAlias

public HostAliases buildHostAlias(int index)

buildFirstHostAlias

public HostAliases buildFirstHostAlias()

buildLastHostAlias

public HostAliases buildLastHostAlias()

buildMatchingHostAlias

public HostAliases buildMatchingHostAlias(Predicate<HostAliasesBuilder> predicate)

hasMatchingHostAlias

public boolean hasMatchingHostAlias(Predicate<HostAliasesBuilder> predicate)

withHostAliases

public A withHostAliases(List<HostAliases> hostAliases)

withHostAliases

public A withHostAliases(HostAliases... hostAliases)

hasHostAliases
```
public boolean hasHostAliases()
```

addNewHostAlias

public SpecFluent.HostAliasesNested<A> addNewHostAlias()

addNewHostAliasLike

public SpecFluent.HostAliasesNested<A> addNewHostAliasLike(HostAliases item)

setNewHostAliasLike

public SpecFluent.HostAliasesNested<A> setNewHostAliasLike(int index,
                                                           HostAliases item)

editHostAlias

public SpecFluent.HostAliasesNested<A> editHostAlias(int index)

editFirstHostAlias

public SpecFluent.HostAliasesNested<A> editFirstHostAlias()

editLastHostAlias

public SpecFluent.HostAliasesNested<A> editLastHostAlias()

editMatchingHostAlias

public SpecFluent.HostAliasesNested<A> editMatchingHostAlias(Predicate<HostAliasesBuilder> predicate)

getHostIPC
```
public Boolean getHostIPC()
```

withHostIPC

public A withHostIPC(Boolean hostIPC)

hasHostIPC
```
public boolean hasHostIPC()
```

getHostNetwork
```
public Boolean getHostNetwork()
```

withHostNetwork

public A withHostNetwork(Boolean hostNetwork)

hasHostNetwork
```
public boolean hasHostNetwork()
```

getHostPID
```
public Boolean getHostPID()
```

withHostPID

public A withHostPID(Boolean hostPID)

hasHostPID
```
public boolean hasHostPID()
```

getHostname
```
public String getHostname()
```

withHostname

public A withHostname(String hostname)

hasHostname
```
public boolean hasHostname()
```

addToImagePullSecrets

public A addToImagePullSecrets(int index,
                               ImagePullSecrets item)

setToImagePullSecrets

public A setToImagePullSecrets(int index,
                               ImagePullSecrets item)

addToImagePullSecrets

public A addToImagePullSecrets(ImagePullSecrets... items)

addAllToSpecImagePullSecrets

public A addAllToSpecImagePullSecrets(Collection<ImagePullSecrets> items)

removeFromImagePullSecrets

public A removeFromImagePullSecrets(ImagePullSecrets... items)

removeAllFromSpecImagePullSecrets

public A removeAllFromSpecImagePullSecrets(Collection<ImagePullSecrets> items)

removeMatchingFromSpecImagePullSecrets

public A removeMatchingFromSpecImagePullSecrets(Predicate<ImagePullSecretsBuilder> predicate)

buildImagePullSecrets

public List<ImagePullSecrets> buildImagePullSecrets()

buildImagePullSecret

public ImagePullSecrets buildImagePullSecret(int index)

buildFirstImagePullSecret

public ImagePullSecrets buildFirstImagePullSecret()

buildLastImagePullSecret

public ImagePullSecrets buildLastImagePullSecret()

buildMatchingImagePullSecret

public ImagePullSecrets buildMatchingImagePullSecret(Predicate<ImagePullSecretsBuilder> predicate)

hasMatchingImagePullSecret

public boolean hasMatchingImagePullSecret(Predicate<ImagePullSecretsBuilder> predicate)

withImagePullSecrets

public A withImagePullSecrets(List<ImagePullSecrets> imagePullSecrets)

withImagePullSecrets

public A withImagePullSecrets(ImagePullSecrets... imagePullSecrets)

hasImagePullSecrets
```
public boolean hasImagePullSecrets()
```

addNewSpecImagePullSecret

public SpecFluent.SpecImagePullSecretsNested<A> addNewSpecImagePullSecret()

addNewImagePullSecretLike

public SpecFluent.SpecImagePullSecretsNested<A> addNewImagePullSecretLike(ImagePullSecrets item)

setNewImagePullSecretLike

public SpecFluent.SpecImagePullSecretsNested<A> setNewImagePullSecretLike(int index,
                                                                          ImagePullSecrets item)

editImagePullSecret

public SpecFluent.SpecImagePullSecretsNested<A> editImagePullSecret(int index)

editFirstImagePullSecret

public SpecFluent.SpecImagePullSecretsNested<A> editFirstImagePullSecret()

editLastImagePullSecret

public SpecFluent.SpecImagePullSecretsNested<A> editLastImagePullSecret()

editMatchingImagePullSecret

public SpecFluent.SpecImagePullSecretsNested<A> editMatchingImagePullSecret(Predicate<ImagePullSecretsBuilder> predicate)

addToInitContainers

public A addToInitContainers(int index,
                             InitContainers item)

setToInitContainers

public A setToInitContainers(int index,
                             InitContainers item)

addToInitContainers

public A addToInitContainers(InitContainers... items)

addAllToInitContainers

public A addAllToInitContainers(Collection<InitContainers> items)

removeFromInitContainers

public A removeFromInitContainers(InitContainers... items)

removeAllFromInitContainers

public A removeAllFromInitContainers(Collection<InitContainers> items)

removeMatchingFromInitContainers

public A removeMatchingFromInitContainers(Predicate<InitContainersBuilder> predicate)

buildInitContainers

public List<InitContainers> buildInitContainers()

buildInitContainer

public InitContainers buildInitContainer(int index)

buildFirstInitContainer

public InitContainers buildFirstInitContainer()

buildLastInitContainer

public InitContainers buildLastInitContainer()

buildMatchingInitContainer

public InitContainers buildMatchingInitContainer(Predicate<InitContainersBuilder> predicate)

hasMatchingInitContainer

public boolean hasMatchingInitContainer(Predicate<InitContainersBuilder> predicate)

withInitContainers

public A withInitContainers(List<InitContainers> initContainers)

withInitContainers

public A withInitContainers(InitContainers... initContainers)

hasInitContainers
```
public boolean hasInitContainers()
```

addNewInitContainer

public SpecFluent.InitContainersNested<A> addNewInitContainer()

addNewInitContainerLike

public SpecFluent.InitContainersNested<A> addNewInitContainerLike(InitContainers item)

setNewInitContainerLike

public SpecFluent.InitContainersNested<A> setNewInitContainerLike(int index,
                                                                  InitContainers item)

editInitContainer

public SpecFluent.InitContainersNested<A> editInitContainer(int index)

editFirstInitContainer

public SpecFluent.InitContainersNested<A> editFirstInitContainer()

editLastInitContainer

public SpecFluent.InitContainersNested<A> editLastInitContainer()

editMatchingInitContainer

public SpecFluent.InitContainersNested<A> editMatchingInitContainer(Predicate<InitContainersBuilder> predicate)

getNodeName
```
public String getNodeName()
```

withNodeName

public A withNodeName(String nodeName)

hasNodeName
```
public boolean hasNodeName()
```

addToNodeSelector

public A addToNodeSelector(String key,
                           String value)

addToNodeSelector

public A addToNodeSelector(Map<String,String> map)

removeFromNodeSelector

public A removeFromNodeSelector(String key)

removeFromNodeSelector

public A removeFromNodeSelector(Map<String,String> map)

getNodeSelector

public Map<String,String> getNodeSelector()

withNodeSelector

public <K,V> A withNodeSelector(Map<String,String> nodeSelector)

hasNodeSelector
```
public boolean hasNodeSelector()
```

buildOs
```
public Os buildOs()
```

withOs
```
public A withOs(Os os)
```

hasOs
```
public boolean hasOs()
```

withNewOs

public SpecFluent.OsNested<A> withNewOs()

withNewOsLike

public SpecFluent.OsNested<A> withNewOsLike(Os item)

editOs

public SpecFluent.OsNested<A> editOs()

editOrNewOs

public SpecFluent.OsNested<A> editOrNewOs()

editOrNewOsLike

public SpecFluent.OsNested<A> editOrNewOsLike(Os item)

addToOverhead

public A addToOverhead(String key,
                       io.fabric8.kubernetes.api.model.IntOrString value)

addToOverhead

public A addToOverhead(Map<String,io.fabric8.kubernetes.api.model.IntOrString> map)

removeFromOverhead

public A removeFromOverhead(String key)

removeFromOverhead

public A removeFromOverhead(Map<String,io.fabric8.kubernetes.api.model.IntOrString> map)

getOverhead

public Map<String,io.fabric8.kubernetes.api.model.IntOrString> getOverhead()

withOverhead

public <K,V> A withOverhead(Map<String,io.fabric8.kubernetes.api.model.IntOrString> overhead)

hasOverhead
```
public boolean hasOverhead()
```

getPreemptionPolicy
```
public String getPreemptionPolicy()
```

withPreemptionPolicy

public A withPreemptionPolicy(String preemptionPolicy)

hasPreemptionPolicy
```
public boolean hasPreemptionPolicy()
```

getPriority
```
public Integer getPriority()
```

withPriority

public A withPriority(Integer priority)

hasPriority
```
public boolean hasPriority()
```

getPriorityClassName
```
public String getPriorityClassName()
```

withPriorityClassName

public A withPriorityClassName(String priorityClassName)

hasPriorityClassName
```
public boolean hasPriorityClassName()
```

addToReadinessGates

public A addToReadinessGates(int index,
                             ReadinessGates item)

setToReadinessGates

public A setToReadinessGates(int index,
                             ReadinessGates item)

addToReadinessGates

public A addToReadinessGates(ReadinessGates... items)

addAllToReadinessGates

public A addAllToReadinessGates(Collection<ReadinessGates> items)

removeFromReadinessGates

public A removeFromReadinessGates(ReadinessGates... items)

removeAllFromReadinessGates

public A removeAllFromReadinessGates(Collection<ReadinessGates> items)

removeMatchingFromReadinessGates

public A removeMatchingFromReadinessGates(Predicate<ReadinessGatesBuilder> predicate)

buildReadinessGates

public List<ReadinessGates> buildReadinessGates()

buildReadinessGate

public ReadinessGates buildReadinessGate(int index)

buildFirstReadinessGate

public ReadinessGates buildFirstReadinessGate()

buildLastReadinessGate

public ReadinessGates buildLastReadinessGate()

buildMatchingReadinessGate

public ReadinessGates buildMatchingReadinessGate(Predicate<ReadinessGatesBuilder> predicate)

hasMatchingReadinessGate

public boolean hasMatchingReadinessGate(Predicate<ReadinessGatesBuilder> predicate)

withReadinessGates

public A withReadinessGates(List<ReadinessGates> readinessGates)

withReadinessGates

public A withReadinessGates(ReadinessGates... readinessGates)

hasReadinessGates
```
public boolean hasReadinessGates()
```

addNewReadinessGate

public SpecFluent.ReadinessGatesNested<A> addNewReadinessGate()

addNewReadinessGateLike

public SpecFluent.ReadinessGatesNested<A> addNewReadinessGateLike(ReadinessGates item)

setNewReadinessGateLike

public SpecFluent.ReadinessGatesNested<A> setNewReadinessGateLike(int index,
                                                                  ReadinessGates item)

editReadinessGate

public SpecFluent.ReadinessGatesNested<A> editReadinessGate(int index)

editFirstReadinessGate

public SpecFluent.ReadinessGatesNested<A> editFirstReadinessGate()

editLastReadinessGate

public SpecFluent.ReadinessGatesNested<A> editLastReadinessGate()

editMatchingReadinessGate

public SpecFluent.ReadinessGatesNested<A> editMatchingReadinessGate(Predicate<ReadinessGatesBuilder> predicate)

getRestartPolicy
```
public String getRestartPolicy()
```

withRestartPolicy

public A withRestartPolicy(String restartPolicy)

hasRestartPolicy
```
public boolean hasRestartPolicy()
```

getRuntimeClassName
```
public String getRuntimeClassName()
```

withRuntimeClassName

public A withRuntimeClassName(String runtimeClassName)

hasRuntimeClassName
```
public boolean hasRuntimeClassName()
```

getSchedulerName
```
public String getSchedulerName()
```

withSchedulerName

public A withSchedulerName(String schedulerName)

hasSchedulerName
```
public boolean hasSchedulerName()
```

buildSecurityContext

public SecurityContext buildSecurityContext()

withSecurityContext

public A withSecurityContext(SecurityContext securityContext)

hasSecurityContext
```
public boolean hasSecurityContext()
```

withNewSecurityContext

public SpecFluent.SecurityContextNested<A> withNewSecurityContext()

withNewSecurityContextLike

public SpecFluent.SecurityContextNested<A> withNewSecurityContextLike(SecurityContext item)

editSecurityContext

public SpecFluent.SecurityContextNested<A> editSecurityContext()

editOrNewSecurityContext

public SpecFluent.SecurityContextNested<A> editOrNewSecurityContext()

editOrNewSecurityContextLike

public SpecFluent.SecurityContextNested<A> editOrNewSecurityContextLike(SecurityContext item)

getServiceAccount
```
public String getServiceAccount()
```

withServiceAccount

public A withServiceAccount(String serviceAccount)

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

getServiceAccountName
```
public String getServiceAccountName()
```

withServiceAccountName

public A withServiceAccountName(String serviceAccountName)

hasServiceAccountName

public boolean hasServiceAccountName()

getSetHostnameAsFQDN
```
public Boolean getSetHostnameAsFQDN()
```

withSetHostnameAsFQDN

public A withSetHostnameAsFQDN(Boolean setHostnameAsFQDN)

hasSetHostnameAsFQDN
```
public boolean hasSetHostnameAsFQDN()
```

getShareProcessNamespace

public Boolean getShareProcessNamespace()

withShareProcessNamespace

public A withShareProcessNamespace(Boolean shareProcessNamespace)

hasShareProcessNamespace

public boolean hasShareProcessNamespace()

getSubdomain
```
public String getSubdomain()
```

withSubdomain

public A withSubdomain(String subdomain)

hasSubdomain
```
public boolean hasSubdomain()
```

getTerminationGracePeriodSeconds

public Long getTerminationGracePeriodSeconds()

withTerminationGracePeriodSeconds

public A withTerminationGracePeriodSeconds(Long terminationGracePeriodSeconds)

hasTerminationGracePeriodSeconds

public boolean hasTerminationGracePeriodSeconds()

addToTolerations

public A addToTolerations(int index,
                          Tolerations item)

setToTolerations

public A setToTolerations(int index,
                          Tolerations item)

addToTolerations

public A addToTolerations(Tolerations... items)

addAllToSpecTolerations

public A addAllToSpecTolerations(Collection<Tolerations> items)

removeFromTolerations

public A removeFromTolerations(Tolerations... items)

removeAllFromSpecTolerations

public A removeAllFromSpecTolerations(Collection<Tolerations> items)

removeMatchingFromSpecTolerations

public A removeMatchingFromSpecTolerations(Predicate<TolerationsBuilder> predicate)

buildTolerations

public List<Tolerations> buildTolerations()

buildToleration

public Tolerations buildToleration(int index)

buildFirstToleration

public Tolerations buildFirstToleration()

buildLastToleration

public Tolerations buildLastToleration()

buildMatchingToleration

public Tolerations buildMatchingToleration(Predicate<TolerationsBuilder> predicate)

hasMatchingToleration

public boolean hasMatchingToleration(Predicate<TolerationsBuilder> predicate)

withTolerations

public A withTolerations(List<Tolerations> tolerations)

withTolerations

public A withTolerations(Tolerations... tolerations)

hasTolerations
```
public boolean hasTolerations()
```

addNewSpecToleration

public SpecFluent.SpecTolerationsNested<A> addNewSpecToleration()

addNewTolerationLike

public SpecFluent.SpecTolerationsNested<A> addNewTolerationLike(Tolerations item)

setNewTolerationLike

public SpecFluent.SpecTolerationsNested<A> setNewTolerationLike(int index,
                                                                Tolerations item)

editToleration

public SpecFluent.SpecTolerationsNested<A> editToleration(int index)

editFirstToleration

public SpecFluent.SpecTolerationsNested<A> editFirstToleration()

editLastToleration

public SpecFluent.SpecTolerationsNested<A> editLastToleration()

editMatchingToleration

public SpecFluent.SpecTolerationsNested<A> editMatchingToleration(Predicate<TolerationsBuilder> predicate)

addToTopologySpreadConstraints

public A addToTopologySpreadConstraints(int index,
                                        TopologySpreadConstraints item)

setToTopologySpreadConstraints

public A setToTopologySpreadConstraints(int index,
                                        TopologySpreadConstraints item)

addToTopologySpreadConstraints

public A addToTopologySpreadConstraints(TopologySpreadConstraints... items)

addAllToTopologySpreadConstraints

public A addAllToTopologySpreadConstraints(Collection<TopologySpreadConstraints> items)

removeFromTopologySpreadConstraints

public A removeFromTopologySpreadConstraints(TopologySpreadConstraints... items)

removeAllFromTopologySpreadConstraints

public A removeAllFromTopologySpreadConstraints(Collection<TopologySpreadConstraints> items)

removeMatchingFromTopologySpreadConstraints

public A removeMatchingFromTopologySpreadConstraints(Predicate<TopologySpreadConstraintsBuilder> predicate)

buildTopologySpreadConstraints

public List<TopologySpreadConstraints> buildTopologySpreadConstraints()

buildTopologySpreadConstraint

public TopologySpreadConstraints buildTopologySpreadConstraint(int index)

buildFirstTopologySpreadConstraint

public TopologySpreadConstraints buildFirstTopologySpreadConstraint()

buildLastTopologySpreadConstraint

public TopologySpreadConstraints buildLastTopologySpreadConstraint()

buildMatchingTopologySpreadConstraint

public TopologySpreadConstraints buildMatchingTopologySpreadConstraint(Predicate<TopologySpreadConstraintsBuilder> predicate)

hasMatchingTopologySpreadConstraint

public boolean hasMatchingTopologySpreadConstraint(Predicate<TopologySpreadConstraintsBuilder> predicate)

withTopologySpreadConstraints

public A withTopologySpreadConstraints(List<TopologySpreadConstraints> topologySpreadConstraints)

withTopologySpreadConstraints

public A withTopologySpreadConstraints(TopologySpreadConstraints... topologySpreadConstraints)

hasTopologySpreadConstraints

public boolean hasTopologySpreadConstraints()

addNewTopologySpreadConstraint

public SpecFluent.TopologySpreadConstraintsNested<A> addNewTopologySpreadConstraint()

addNewTopologySpreadConstraintLike

public SpecFluent.TopologySpreadConstraintsNested<A> addNewTopologySpreadConstraintLike(TopologySpreadConstraints item)

setNewTopologySpreadConstraintLike

public SpecFluent.TopologySpreadConstraintsNested<A> setNewTopologySpreadConstraintLike(int index,
                                                                                        TopologySpreadConstraints item)

editTopologySpreadConstraint

public SpecFluent.TopologySpreadConstraintsNested<A> editTopologySpreadConstraint(int index)

editFirstTopologySpreadConstraint

public SpecFluent.TopologySpreadConstraintsNested<A> editFirstTopologySpreadConstraint()

editLastTopologySpreadConstraint

public SpecFluent.TopologySpreadConstraintsNested<A> editLastTopologySpreadConstraint()

editMatchingTopologySpreadConstraint

public SpecFluent.TopologySpreadConstraintsNested<A> editMatchingTopologySpreadConstraint(Predicate<TopologySpreadConstraintsBuilder> predicate)

addToVolumes

public A addToVolumes(int index,
                      Volumes item)

setToVolumes

public A setToVolumes(int index,
                      Volumes item)

addToVolumes

public A addToVolumes(Volumes... items)

addAllToVolumes

public A addAllToVolumes(Collection<Volumes> items)

removeFromVolumes

public A removeFromVolumes(Volumes... items)

removeAllFromVolumes

public A removeAllFromVolumes(Collection<Volumes> items)

removeMatchingFromVolumes

public A removeMatchingFromVolumes(Predicate<VolumesBuilder> predicate)

buildVolumes
```
public List<Volumes> buildVolumes()
```

buildVolume

public Volumes buildVolume(int index)

buildFirstVolume
```
public Volumes buildFirstVolume()
```

buildLastVolume
```
public Volumes buildLastVolume()
```

buildMatchingVolume

public Volumes buildMatchingVolume(Predicate<VolumesBuilder> predicate)

hasMatchingVolume

public boolean hasMatchingVolume(Predicate<VolumesBuilder> predicate)

withVolumes

public A withVolumes(List<Volumes> volumes)

withVolumes

public A withVolumes(Volumes... volumes)

hasVolumes
```
public boolean hasVolumes()
```

addNewVolume

public SpecFluent.VolumesNested<A> addNewVolume()

addNewVolumeLike

public SpecFluent.VolumesNested<A> addNewVolumeLike(Volumes item)

setNewVolumeLike

public SpecFluent.VolumesNested<A> setNewVolumeLike(int index,
                                                    Volumes item)

editVolume

public SpecFluent.VolumesNested<A> editVolume(int index)

editFirstVolume

public SpecFluent.VolumesNested<A> editFirstVolume()

editLastVolume

public SpecFluent.VolumesNested<A> editLastVolume()

editMatchingVolume

public SpecFluent.VolumesNested<A> editMatchingVolume(Predicate<VolumesBuilder> predicate)

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

equals in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends SpecFluent<A>>

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

hashCode in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends SpecFluent<A>>

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

toString in class Object

withAutomountServiceAccountToken

public A withAutomountServiceAccountToken()

withEnableServiceLinks
```
public A withEnableServiceLinks()
```

withHostIPC
```
public A withHostIPC()
```

withHostNetwork
```
public A withHostNetwork()
```

withHostPID
```
public A withHostPID()
```

withSetHostnameAsFQDN
```
public A withSetHostnameAsFQDN()
```

withShareProcessNamespace
```
public A withShareProcessNamespace()
```

Constructors
Constructor	Description
`SpecFluent()`
`SpecFluent(Spec instance)`

Class SpecFluent<A extends SpecFluent<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

SpecFluent

SpecFluent

Method Detail

getActiveDeadlineSeconds

withActiveDeadlineSeconds

hasActiveDeadlineSeconds

buildAffinity

withAffinity

hasAffinity

withNewSpecAffinity

withNewAffinityLike

editSpecAffinity

editOrNewAffinity

editOrNewAffinityLike

getAutomountServiceAccountToken

withAutomountServiceAccountToken

hasAutomountServiceAccountToken

addToContainers

setToContainers

addToContainers

addAllToContainers

removeFromContainers

removeAllFromContainers

removeMatchingFromContainers

buildContainers

buildContainer

buildFirstContainer

buildLastContainer

buildMatchingContainer

hasMatchingContainer

withContainers

withContainers

hasContainers

addNewContainer

addNewContainerLike

setNewContainerLike

editContainer

editFirstContainer

editLastContainer

editMatchingContainer

buildDnsConfig

withDnsConfig

hasDnsConfig

withNewDnsConfig

withNewDnsConfigLike

editDnsConfig

editOrNewDnsConfig

editOrNewDnsConfigLike

getDnsPolicy

withDnsPolicy

hasDnsPolicy

getEnableServiceLinks

withEnableServiceLinks

hasEnableServiceLinks

addToEphemeralContainers

setToEphemeralContainers

addToEphemeralContainers

addAllToEphemeralContainers

removeFromEphemeralContainers

removeAllFromEphemeralContainers

removeMatchingFromEphemeralContainers

buildEphemeralContainers

buildEphemeralContainer

buildFirstEphemeralContainer

buildLastEphemeralContainer

buildMatchingEphemeralContainer

hasMatchingEphemeralContainer

withEphemeralContainers

withEphemeralContainers

hasEphemeralContainers