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

All Implemented Interfaces:

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

Direct Known Subclasses:

ContainersBuilder, SpecFluent.ContainersNested
```
public class ContainersFluent<A extends ContainersFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`ContainersFluent.ContainersEnvNested<N>`
`class`	`ContainersFluent.ContainersSecurityContextNested<N>`
`class`	`ContainersFluent.EnvFromNested<N>`
`class`	`ContainersFluent.LifecycleNested<N>`
`class`	`ContainersFluent.LivenessProbeNested<N>`
`class`	`ContainersFluent.PortsNested<N>`
`class`	`ContainersFluent.ReadinessProbeNested<N>`
`class`	`ContainersFluent.ResourcesNested<N>`
`class`	`ContainersFluent.StartupProbeNested<N>`
`class`	`ContainersFluent.VolumeDevicesNested<N>`
`class`	`ContainersFluent.VolumeMountsNested<N>`

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

Constructor Summary

Constructors
Constructor Description

ContainersFluent()

ContainersFluent(Containers instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToArgs(Collection<String> items)`
`A`	`addAllToCommand(Collection<String> items)`
`A`	`addAllToContainersEnv(Collection<Env> items)`
`A`	`addAllToEnvFrom(Collection<EnvFrom> items)`
`A`	`addAllToPorts(Collection<Ports> items)`
`A`	`addAllToVolumeDevices(Collection<VolumeDevices> items)`
`A`	`addAllToVolumeMounts(Collection<VolumeMounts> items)`
`ContainersFluent.ContainersEnvNested<A>`	`addNewContainersEnv()`
`ContainersFluent.EnvFromNested<A>`	`addNewEnvFrom()`
`ContainersFluent.EnvFromNested<A>`	`addNewEnvFromLike(EnvFrom item)`
`ContainersFluent.ContainersEnvNested<A>`	`addNewEnvLike(Env item)`
`ContainersFluent.PortsNested<A>`	`addNewPort()`
`ContainersFluent.PortsNested<A>`	`addNewPortLike(Ports item)`
`ContainersFluent.VolumeDevicesNested<A>`	`addNewVolumeDevice()`
`ContainersFluent.VolumeDevicesNested<A>`	`addNewVolumeDeviceLike(VolumeDevices item)`
`ContainersFluent.VolumeMountsNested<A>`	`addNewVolumeMount()`
`ContainersFluent.VolumeMountsNested<A>`	`addNewVolumeMountLike(VolumeMounts item)`
`A`	`addToArgs(int index, String item)`
`A`	`addToArgs(String... items)`
`A`	`addToCommand(int index, String item)`
`A`	`addToCommand(String... items)`
`A`	`addToEnv(int index, Env item)`
`A`	`addToEnv(Env... items)`
`A`	`addToEnvFrom(int index, EnvFrom item)`
`A`	`addToEnvFrom(EnvFrom... items)`
`A`	`addToPorts(int index, Ports item)`
`A`	`addToPorts(Ports... items)`
`A`	`addToVolumeDevices(int index, VolumeDevices item)`
`A`	`addToVolumeDevices(VolumeDevices... items)`
`A`	`addToVolumeMounts(int index, VolumeMounts item)`
`A`	`addToVolumeMounts(VolumeMounts... items)`
`List<Env>`	`buildEnv()`
`Env`	`buildEnv(int index)`
`List<EnvFrom>`	`buildEnvFrom()`
`EnvFrom`	`buildEnvFrom(int index)`
`Env`	`buildFirstEnv()`
`EnvFrom`	`buildFirstEnvFrom()`
`Ports`	`buildFirstPort()`
`VolumeDevices`	`buildFirstVolumeDevice()`
`VolumeMounts`	`buildFirstVolumeMount()`
`Env`	`buildLastEnv()`
`EnvFrom`	`buildLastEnvFrom()`
`Ports`	`buildLastPort()`
`VolumeDevices`	`buildLastVolumeDevice()`
`VolumeMounts`	`buildLastVolumeMount()`
`Lifecycle`	`buildLifecycle()`
`LivenessProbe`	`buildLivenessProbe()`
`Env`	`buildMatchingEnv(Predicate<EnvBuilder> predicate)`
`EnvFrom`	`buildMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)`
`Ports`	`buildMatchingPort(Predicate<PortsBuilder> predicate)`
`VolumeDevices`	`buildMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)`
`VolumeMounts`	`buildMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)`
`Ports`	`buildPort(int index)`
`List<Ports>`	`buildPorts()`
`ReadinessProbe`	`buildReadinessProbe()`
`Resources`	`buildResources()`
`SecurityContext`	`buildSecurityContext()`
`StartupProbe`	`buildStartupProbe()`
`VolumeDevices`	`buildVolumeDevice(int index)`
`List<VolumeDevices>`	`buildVolumeDevices()`
`VolumeMounts`	`buildVolumeMount(int index)`
`List<VolumeMounts>`	`buildVolumeMounts()`
`ContainersFluent.ContainersSecurityContextNested<A>`	`editContainersSecurityContext()`
`ContainersFluent.ContainersEnvNested<A>`	`editEnv(int index)`
`ContainersFluent.EnvFromNested<A>`	`editEnvFrom(int index)`
`ContainersFluent.ContainersEnvNested<A>`	`editFirstEnv()`
`ContainersFluent.EnvFromNested<A>`	`editFirstEnvFrom()`
`ContainersFluent.PortsNested<A>`	`editFirstPort()`
`ContainersFluent.VolumeDevicesNested<A>`	`editFirstVolumeDevice()`
`ContainersFluent.VolumeMountsNested<A>`	`editFirstVolumeMount()`
`ContainersFluent.ContainersEnvNested<A>`	`editLastEnv()`
`ContainersFluent.EnvFromNested<A>`	`editLastEnvFrom()`
`ContainersFluent.PortsNested<A>`	`editLastPort()`
`ContainersFluent.VolumeDevicesNested<A>`	`editLastVolumeDevice()`
`ContainersFluent.VolumeMountsNested<A>`	`editLastVolumeMount()`
`ContainersFluent.LifecycleNested<A>`	`editLifecycle()`
`ContainersFluent.LivenessProbeNested<A>`	`editLivenessProbe()`
`ContainersFluent.ContainersEnvNested<A>`	`editMatchingEnv(Predicate<EnvBuilder> predicate)`
`ContainersFluent.EnvFromNested<A>`	`editMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)`
`ContainersFluent.PortsNested<A>`	`editMatchingPort(Predicate<PortsBuilder> predicate)`
`ContainersFluent.VolumeDevicesNested<A>`	`editMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)`
`ContainersFluent.VolumeMountsNested<A>`	`editMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)`
`ContainersFluent.LifecycleNested<A>`	`editOrNewLifecycle()`
`ContainersFluent.LifecycleNested<A>`	`editOrNewLifecycleLike(Lifecycle item)`
`ContainersFluent.LivenessProbeNested<A>`	`editOrNewLivenessProbe()`
`ContainersFluent.LivenessProbeNested<A>`	`editOrNewLivenessProbeLike(LivenessProbe item)`
`ContainersFluent.ReadinessProbeNested<A>`	`editOrNewReadinessProbe()`
`ContainersFluent.ReadinessProbeNested<A>`	`editOrNewReadinessProbeLike(ReadinessProbe item)`
`ContainersFluent.ResourcesNested<A>`	`editOrNewResources()`
`ContainersFluent.ResourcesNested<A>`	`editOrNewResourcesLike(Resources item)`
`ContainersFluent.ContainersSecurityContextNested<A>`	`editOrNewSecurityContext()`
`ContainersFluent.ContainersSecurityContextNested<A>`	`editOrNewSecurityContextLike(SecurityContext item)`
`ContainersFluent.StartupProbeNested<A>`	`editOrNewStartupProbe()`
`ContainersFluent.StartupProbeNested<A>`	`editOrNewStartupProbeLike(StartupProbe item)`
`ContainersFluent.PortsNested<A>`	`editPort(int index)`
`ContainersFluent.ReadinessProbeNested<A>`	`editReadinessProbe()`
`ContainersFluent.ResourcesNested<A>`	`editResources()`
`ContainersFluent.StartupProbeNested<A>`	`editStartupProbe()`
`ContainersFluent.VolumeDevicesNested<A>`	`editVolumeDevice(int index)`
`ContainersFluent.VolumeMountsNested<A>`	`editVolumeMount(int index)`
`boolean`	`equals(Object o)`
`String`	`getArg(int index)`
`List<String>`	`getArgs()`
`List<String>`	`getCommand()`
`String`	`getCommand(int index)`
`String`	`getFirstArg()`
`String`	`getFirstCommand()`
`String`	`getImage()`
`String`	`getImagePullPolicy()`
`String`	`getLastArg()`
`String`	`getLastCommand()`
`String`	`getMatchingArg(Predicate<String> predicate)`
`String`	`getMatchingCommand(Predicate<String> predicate)`
`String`	`getName()`
`Boolean`	`getStdin()`
`Boolean`	`getStdinOnce()`
`String`	`getTerminationMessagePath()`
`String`	`getTerminationMessagePolicy()`
`Boolean`	`getTty()`
`String`	`getWorkingDir()`
`boolean`	`hasArgs()`
`boolean`	`hasCommand()`
`boolean`	`hasEnv()`
`boolean`	`hasEnvFrom()`
`int`	`hashCode()`
`boolean`	`hasImage()`
`boolean`	`hasImagePullPolicy()`
`boolean`	`hasLifecycle()`
`boolean`	`hasLivenessProbe()`
`boolean`	`hasMatchingArg(Predicate<String> predicate)`
`boolean`	`hasMatchingCommand(Predicate<String> predicate)`
`boolean`	`hasMatchingEnv(Predicate<EnvBuilder> predicate)`
`boolean`	`hasMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)`
`boolean`	`hasMatchingPort(Predicate<PortsBuilder> predicate)`
`boolean`	`hasMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)`
`boolean`	`hasMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)`
`boolean`	`hasName()`
`boolean`	`hasPorts()`
`boolean`	`hasReadinessProbe()`
`boolean`	`hasResources()`
`boolean`	`hasSecurityContext()`
`boolean`	`hasStartupProbe()`
`boolean`	`hasStdin()`
`boolean`	`hasStdinOnce()`
`boolean`	`hasTerminationMessagePath()`
`boolean`	`hasTerminationMessagePolicy()`
`boolean`	`hasTty()`
`boolean`	`hasVolumeDevices()`
`boolean`	`hasVolumeMounts()`
`boolean`	`hasWorkingDir()`
`A`	`removeAllFromArgs(Collection<String> items)`
`A`	`removeAllFromCommand(Collection<String> items)`
`A`	`removeAllFromContainersEnv(Collection<Env> items)`
`A`	`removeAllFromEnvFrom(Collection<EnvFrom> items)`
`A`	`removeAllFromPorts(Collection<Ports> items)`
`A`	`removeAllFromVolumeDevices(Collection<VolumeDevices> items)`
`A`	`removeAllFromVolumeMounts(Collection<VolumeMounts> items)`
`A`	`removeFromArgs(String... items)`
`A`	`removeFromCommand(String... items)`
`A`	`removeFromEnv(Env... items)`
`A`	`removeFromEnvFrom(EnvFrom... items)`
`A`	`removeFromPorts(Ports... items)`
`A`	`removeFromVolumeDevices(VolumeDevices... items)`
`A`	`removeFromVolumeMounts(VolumeMounts... items)`
`A`	`removeMatchingFromContainersEnv(Predicate<EnvBuilder> predicate)`
`A`	`removeMatchingFromEnvFrom(Predicate<EnvFromBuilder> predicate)`
`A`	`removeMatchingFromPorts(Predicate<PortsBuilder> predicate)`
`A`	`removeMatchingFromVolumeDevices(Predicate<VolumeDevicesBuilder> predicate)`
`A`	`removeMatchingFromVolumeMounts(Predicate<VolumeMountsBuilder> predicate)`
`ContainersFluent.EnvFromNested<A>`	`setNewEnvFromLike(int index, EnvFrom item)`
`ContainersFluent.ContainersEnvNested<A>`	`setNewEnvLike(int index, Env item)`
`ContainersFluent.PortsNested<A>`	`setNewPortLike(int index, Ports item)`
`ContainersFluent.VolumeDevicesNested<A>`	`setNewVolumeDeviceLike(int index, VolumeDevices item)`
`ContainersFluent.VolumeMountsNested<A>`	`setNewVolumeMountLike(int index, VolumeMounts item)`
`A`	`setToArgs(int index, String item)`
`A`	`setToCommand(int index, String item)`
`A`	`setToEnv(int index, Env item)`
`A`	`setToEnvFrom(int index, EnvFrom item)`
`A`	`setToPorts(int index, Ports item)`
`A`	`setToVolumeDevices(int index, VolumeDevices item)`
`A`	`setToVolumeMounts(int index, VolumeMounts item)`
`String`	`toString()`
`A`	`withArgs(String... args)`
`A`	`withArgs(List<String> args)`
`A`	`withCommand(String... command)`
`A`	`withCommand(List<String> command)`
`A`	`withEnv(Env... env)`
`A`	`withEnv(List<Env> env)`
`A`	`withEnvFrom(EnvFrom... envFrom)`
`A`	`withEnvFrom(List<EnvFrom> envFrom)`
`A`	`withImage(String image)`
`A`	`withImagePullPolicy(String imagePullPolicy)`
`A`	`withLifecycle(Lifecycle lifecycle)`
`A`	`withLivenessProbe(LivenessProbe livenessProbe)`
`A`	`withName(String name)`
`ContainersFluent.ContainersSecurityContextNested<A>`	`withNewContainersSecurityContext()`
`ContainersFluent.LifecycleNested<A>`	`withNewLifecycle()`
`ContainersFluent.LifecycleNested<A>`	`withNewLifecycleLike(Lifecycle item)`
`ContainersFluent.LivenessProbeNested<A>`	`withNewLivenessProbe()`
`ContainersFluent.LivenessProbeNested<A>`	`withNewLivenessProbeLike(LivenessProbe item)`
`ContainersFluent.ReadinessProbeNested<A>`	`withNewReadinessProbe()`
`ContainersFluent.ReadinessProbeNested<A>`	`withNewReadinessProbeLike(ReadinessProbe item)`
`ContainersFluent.ResourcesNested<A>`	`withNewResources()`
`ContainersFluent.ResourcesNested<A>`	`withNewResourcesLike(Resources item)`
`ContainersFluent.ContainersSecurityContextNested<A>`	`withNewSecurityContextLike(SecurityContext item)`
`ContainersFluent.StartupProbeNested<A>`	`withNewStartupProbe()`
`ContainersFluent.StartupProbeNested<A>`	`withNewStartupProbeLike(StartupProbe item)`
`A`	`withPorts(Ports... ports)`
`A`	`withPorts(List<Ports> ports)`
`A`	`withReadinessProbe(ReadinessProbe readinessProbe)`
`A`	`withResources(Resources resources)`
`A`	`withSecurityContext(SecurityContext securityContext)`
`A`	`withStartupProbe(StartupProbe startupProbe)`
`A`	`withStdin()`
`A`	`withStdin(Boolean stdin)`
`A`	`withStdinOnce()`
`A`	`withStdinOnce(Boolean stdinOnce)`
`A`	`withTerminationMessagePath(String terminationMessagePath)`
`A`	`withTerminationMessagePolicy(String terminationMessagePolicy)`
`A`	`withTty()`
`A`	`withTty(Boolean tty)`
`A`	`withVolumeDevices(VolumeDevices... volumeDevices)`
`A`	`withVolumeDevices(List<VolumeDevices> volumeDevices)`
`A`	`withVolumeMounts(VolumeMounts... volumeMounts)`
`A`	`withVolumeMounts(List<VolumeMounts> volumeMounts)`
`A`	`withWorkingDir(String workingDir)`

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

ContainersFluent
```
public ContainersFluent()
```

ContainersFluent

public ContainersFluent(Containers instance)

Method Detail

addToArgs

public A addToArgs(int index,
                   String item)

setToArgs

public A setToArgs(int index,
                   String item)

addToArgs

public A addToArgs(String... items)

addAllToArgs

public A addAllToArgs(Collection<String> items)

removeFromArgs

public A removeFromArgs(String... items)

removeAllFromArgs

public A removeAllFromArgs(Collection<String> items)

getArgs
```
public List<String> getArgs()
```

getArg
```
public String getArg(int index)
```

getFirstArg
```
public String getFirstArg()
```

getLastArg
```
public String getLastArg()
```

getMatchingArg

public String getMatchingArg(Predicate<String> predicate)

hasMatchingArg

public boolean hasMatchingArg(Predicate<String> predicate)

withArgs

public A withArgs(List<String> args)

withArgs
```
public A withArgs(String... args)
```

hasArgs
```
public boolean hasArgs()
```

addToCommand

public A addToCommand(int index,
                      String item)

setToCommand

public A setToCommand(int index,
                      String item)

addToCommand

public A addToCommand(String... items)

addAllToCommand

public A addAllToCommand(Collection<String> items)

removeFromCommand

public A removeFromCommand(String... items)

removeAllFromCommand

public A removeAllFromCommand(Collection<String> items)

getCommand
```
public List<String> getCommand()
```

getCommand

public String getCommand(int index)

getFirstCommand
```
public String getFirstCommand()
```

getLastCommand
```
public String getLastCommand()
```

getMatchingCommand

public String getMatchingCommand(Predicate<String> predicate)

hasMatchingCommand

public boolean hasMatchingCommand(Predicate<String> predicate)

withCommand

public A withCommand(List<String> command)

withCommand

public A withCommand(String... command)

hasCommand
```
public boolean hasCommand()
```

addToEnv

public A addToEnv(int index,
                  Env item)

setToEnv

public A setToEnv(int index,
                  Env item)

addToEnv
```
public A addToEnv(Env... items)
```

addAllToContainersEnv

public A addAllToContainersEnv(Collection<Env> items)

removeFromEnv

public A removeFromEnv(Env... items)

removeAllFromContainersEnv

public A removeAllFromContainersEnv(Collection<Env> items)

removeMatchingFromContainersEnv

public A removeMatchingFromContainersEnv(Predicate<EnvBuilder> predicate)

buildEnv
```
public List<Env> buildEnv()
```

buildEnv
```
public Env buildEnv(int index)
```

buildFirstEnv
```
public Env buildFirstEnv()
```

buildLastEnv
```
public Env buildLastEnv()
```

buildMatchingEnv

public Env buildMatchingEnv(Predicate<EnvBuilder> predicate)

hasMatchingEnv

public boolean hasMatchingEnv(Predicate<EnvBuilder> predicate)

withEnv
```
public A withEnv(List<Env> env)
```

withEnv
```
public A withEnv(Env... env)
```

hasEnv
```
public boolean hasEnv()
```

addNewContainersEnv

public ContainersFluent.ContainersEnvNested<A> addNewContainersEnv()

addNewEnvLike

public ContainersFluent.ContainersEnvNested<A> addNewEnvLike(Env item)

setNewEnvLike

public ContainersFluent.ContainersEnvNested<A> setNewEnvLike(int index,
                                                             Env item)

editEnv

public ContainersFluent.ContainersEnvNested<A> editEnv(int index)

editFirstEnv

public ContainersFluent.ContainersEnvNested<A> editFirstEnv()

editLastEnv

public ContainersFluent.ContainersEnvNested<A> editLastEnv()

editMatchingEnv

public ContainersFluent.ContainersEnvNested<A> editMatchingEnv(Predicate<EnvBuilder> predicate)

addToEnvFrom

public A addToEnvFrom(int index,
                      EnvFrom item)

setToEnvFrom

public A setToEnvFrom(int index,
                      EnvFrom item)

addToEnvFrom

public A addToEnvFrom(EnvFrom... items)

addAllToEnvFrom

public A addAllToEnvFrom(Collection<EnvFrom> items)

removeFromEnvFrom

public A removeFromEnvFrom(EnvFrom... items)

removeAllFromEnvFrom

public A removeAllFromEnvFrom(Collection<EnvFrom> items)

removeMatchingFromEnvFrom

public A removeMatchingFromEnvFrom(Predicate<EnvFromBuilder> predicate)

buildEnvFrom
```
public List<EnvFrom> buildEnvFrom()
```

buildEnvFrom

public EnvFrom buildEnvFrom(int index)

buildFirstEnvFrom
```
public EnvFrom buildFirstEnvFrom()
```

buildLastEnvFrom
```
public EnvFrom buildLastEnvFrom()
```

buildMatchingEnvFrom

public EnvFrom buildMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)

hasMatchingEnvFrom

public boolean hasMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)

withEnvFrom

public A withEnvFrom(List<EnvFrom> envFrom)

withEnvFrom

public A withEnvFrom(EnvFrom... envFrom)

hasEnvFrom
```
public boolean hasEnvFrom()
```

addNewEnvFrom

public ContainersFluent.EnvFromNested<A> addNewEnvFrom()

addNewEnvFromLike

public ContainersFluent.EnvFromNested<A> addNewEnvFromLike(EnvFrom item)

setNewEnvFromLike

public ContainersFluent.EnvFromNested<A> setNewEnvFromLike(int index,
                                                           EnvFrom item)

editEnvFrom

public ContainersFluent.EnvFromNested<A> editEnvFrom(int index)

editFirstEnvFrom

public ContainersFluent.EnvFromNested<A> editFirstEnvFrom()

editLastEnvFrom

public ContainersFluent.EnvFromNested<A> editLastEnvFrom()

editMatchingEnvFrom

public ContainersFluent.EnvFromNested<A> editMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)

getImage
```
public String getImage()
```

withImage
```
public A withImage(String image)
```

hasImage
```
public boolean hasImage()
```

getImagePullPolicy
```
public String getImagePullPolicy()
```

withImagePullPolicy

public A withImagePullPolicy(String imagePullPolicy)

hasImagePullPolicy
```
public boolean hasImagePullPolicy()
```

buildLifecycle
```
public Lifecycle buildLifecycle()
```

withLifecycle

public A withLifecycle(Lifecycle lifecycle)

hasLifecycle
```
public boolean hasLifecycle()
```

withNewLifecycle

public ContainersFluent.LifecycleNested<A> withNewLifecycle()

withNewLifecycleLike

public ContainersFluent.LifecycleNested<A> withNewLifecycleLike(Lifecycle item)

editLifecycle

public ContainersFluent.LifecycleNested<A> editLifecycle()

editOrNewLifecycle

public ContainersFluent.LifecycleNested<A> editOrNewLifecycle()

editOrNewLifecycleLike

public ContainersFluent.LifecycleNested<A> editOrNewLifecycleLike(Lifecycle item)

buildLivenessProbe

public LivenessProbe buildLivenessProbe()

withLivenessProbe

public A withLivenessProbe(LivenessProbe livenessProbe)

hasLivenessProbe
```
public boolean hasLivenessProbe()
```

withNewLivenessProbe

public ContainersFluent.LivenessProbeNested<A> withNewLivenessProbe()

withNewLivenessProbeLike

public ContainersFluent.LivenessProbeNested<A> withNewLivenessProbeLike(LivenessProbe item)

editLivenessProbe

public ContainersFluent.LivenessProbeNested<A> editLivenessProbe()

editOrNewLivenessProbe

public ContainersFluent.LivenessProbeNested<A> editOrNewLivenessProbe()

editOrNewLivenessProbeLike

public ContainersFluent.LivenessProbeNested<A> editOrNewLivenessProbeLike(LivenessProbe item)

getName
```
public String getName()
```

withName
```
public A withName(String name)
```

hasName
```
public boolean hasName()
```

addToPorts

public A addToPorts(int index,
                    Ports item)

setToPorts

public A setToPorts(int index,
                    Ports item)

addToPorts

public A addToPorts(Ports... items)

addAllToPorts

public A addAllToPorts(Collection<Ports> items)

removeFromPorts

public A removeFromPorts(Ports... items)

removeAllFromPorts

public A removeAllFromPorts(Collection<Ports> items)

removeMatchingFromPorts

public A removeMatchingFromPorts(Predicate<PortsBuilder> predicate)

buildPorts
```
public List<Ports> buildPorts()
```

buildPort
```
public Ports buildPort(int index)
```

buildFirstPort
```
public Ports buildFirstPort()
```

buildLastPort
```
public Ports buildLastPort()
```

buildMatchingPort

public Ports buildMatchingPort(Predicate<PortsBuilder> predicate)

hasMatchingPort

public boolean hasMatchingPort(Predicate<PortsBuilder> predicate)

withPorts

public A withPorts(List<Ports> ports)

withPorts

public A withPorts(Ports... ports)

hasPorts
```
public boolean hasPorts()
```

addNewPort

public ContainersFluent.PortsNested<A> addNewPort()

addNewPortLike

public ContainersFluent.PortsNested<A> addNewPortLike(Ports item)

setNewPortLike

public ContainersFluent.PortsNested<A> setNewPortLike(int index,
                                                      Ports item)

editPort

public ContainersFluent.PortsNested<A> editPort(int index)

editFirstPort

public ContainersFluent.PortsNested<A> editFirstPort()

editLastPort

public ContainersFluent.PortsNested<A> editLastPort()

editMatchingPort

public ContainersFluent.PortsNested<A> editMatchingPort(Predicate<PortsBuilder> predicate)

buildReadinessProbe

public ReadinessProbe buildReadinessProbe()

withReadinessProbe

public A withReadinessProbe(ReadinessProbe readinessProbe)

hasReadinessProbe
```
public boolean hasReadinessProbe()
```

withNewReadinessProbe

public ContainersFluent.ReadinessProbeNested<A> withNewReadinessProbe()

withNewReadinessProbeLike

public ContainersFluent.ReadinessProbeNested<A> withNewReadinessProbeLike(ReadinessProbe item)

editReadinessProbe

public ContainersFluent.ReadinessProbeNested<A> editReadinessProbe()

editOrNewReadinessProbe

public ContainersFluent.ReadinessProbeNested<A> editOrNewReadinessProbe()

editOrNewReadinessProbeLike

public ContainersFluent.ReadinessProbeNested<A> editOrNewReadinessProbeLike(ReadinessProbe item)

buildResources
```
public Resources buildResources()
```

withResources

public A withResources(Resources resources)

hasResources
```
public boolean hasResources()
```

withNewResources

public ContainersFluent.ResourcesNested<A> withNewResources()

withNewResourcesLike

public ContainersFluent.ResourcesNested<A> withNewResourcesLike(Resources item)

editResources

public ContainersFluent.ResourcesNested<A> editResources()

editOrNewResources

public ContainersFluent.ResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public ContainersFluent.ResourcesNested<A> editOrNewResourcesLike(Resources item)

buildSecurityContext

public SecurityContext buildSecurityContext()

withSecurityContext

public A withSecurityContext(SecurityContext securityContext)

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

withNewContainersSecurityContext

public ContainersFluent.ContainersSecurityContextNested<A> withNewContainersSecurityContext()

withNewSecurityContextLike

public ContainersFluent.ContainersSecurityContextNested<A> withNewSecurityContextLike(SecurityContext item)

editContainersSecurityContext

public ContainersFluent.ContainersSecurityContextNested<A> editContainersSecurityContext()

editOrNewSecurityContext

public ContainersFluent.ContainersSecurityContextNested<A> editOrNewSecurityContext()

editOrNewSecurityContextLike

public ContainersFluent.ContainersSecurityContextNested<A> editOrNewSecurityContextLike(SecurityContext item)

buildStartupProbe

public StartupProbe buildStartupProbe()

withStartupProbe

public A withStartupProbe(StartupProbe startupProbe)

hasStartupProbe
```
public boolean hasStartupProbe()
```

withNewStartupProbe

public ContainersFluent.StartupProbeNested<A> withNewStartupProbe()

withNewStartupProbeLike

public ContainersFluent.StartupProbeNested<A> withNewStartupProbeLike(StartupProbe item)

editStartupProbe

public ContainersFluent.StartupProbeNested<A> editStartupProbe()

editOrNewStartupProbe

public ContainersFluent.StartupProbeNested<A> editOrNewStartupProbe()

editOrNewStartupProbeLike

public ContainersFluent.StartupProbeNested<A> editOrNewStartupProbeLike(StartupProbe item)

getStdin
```
public Boolean getStdin()
```

withStdin
```
public A withStdin(Boolean stdin)
```

hasStdin
```
public boolean hasStdin()
```

getStdinOnce
```
public Boolean getStdinOnce()
```

withStdinOnce

public A withStdinOnce(Boolean stdinOnce)

hasStdinOnce
```
public boolean hasStdinOnce()
```

getTerminationMessagePath

public String getTerminationMessagePath()

withTerminationMessagePath

public A withTerminationMessagePath(String terminationMessagePath)

hasTerminationMessagePath

public boolean hasTerminationMessagePath()

getTerminationMessagePolicy

public String getTerminationMessagePolicy()

withTerminationMessagePolicy

public A withTerminationMessagePolicy(String terminationMessagePolicy)

hasTerminationMessagePolicy

public boolean hasTerminationMessagePolicy()

getTty
```
public Boolean getTty()
```

withTty
```
public A withTty(Boolean tty)
```

hasTty
```
public boolean hasTty()
```

addToVolumeDevices

public A addToVolumeDevices(int index,
                            VolumeDevices item)

setToVolumeDevices

public A setToVolumeDevices(int index,
                            VolumeDevices item)

addToVolumeDevices

public A addToVolumeDevices(VolumeDevices... items)

addAllToVolumeDevices

public A addAllToVolumeDevices(Collection<VolumeDevices> items)

removeFromVolumeDevices

public A removeFromVolumeDevices(VolumeDevices... items)

removeAllFromVolumeDevices

public A removeAllFromVolumeDevices(Collection<VolumeDevices> items)

removeMatchingFromVolumeDevices

public A removeMatchingFromVolumeDevices(Predicate<VolumeDevicesBuilder> predicate)

buildVolumeDevices

public List<VolumeDevices> buildVolumeDevices()

buildVolumeDevice

public VolumeDevices buildVolumeDevice(int index)

buildFirstVolumeDevice

public VolumeDevices buildFirstVolumeDevice()

buildLastVolumeDevice

public VolumeDevices buildLastVolumeDevice()

buildMatchingVolumeDevice

public VolumeDevices buildMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)

hasMatchingVolumeDevice

public boolean hasMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)

withVolumeDevices

public A withVolumeDevices(List<VolumeDevices> volumeDevices)

withVolumeDevices

public A withVolumeDevices(VolumeDevices... volumeDevices)

hasVolumeDevices
```
public boolean hasVolumeDevices()
```

addNewVolumeDevice

public ContainersFluent.VolumeDevicesNested<A> addNewVolumeDevice()

addNewVolumeDeviceLike

public ContainersFluent.VolumeDevicesNested<A> addNewVolumeDeviceLike(VolumeDevices item)

setNewVolumeDeviceLike

public ContainersFluent.VolumeDevicesNested<A> setNewVolumeDeviceLike(int index,
                                                                      VolumeDevices item)

editVolumeDevice

public ContainersFluent.VolumeDevicesNested<A> editVolumeDevice(int index)

editFirstVolumeDevice

public ContainersFluent.VolumeDevicesNested<A> editFirstVolumeDevice()

editLastVolumeDevice

public ContainersFluent.VolumeDevicesNested<A> editLastVolumeDevice()

editMatchingVolumeDevice

public ContainersFluent.VolumeDevicesNested<A> editMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)

addToVolumeMounts

public A addToVolumeMounts(int index,
                           VolumeMounts item)

setToVolumeMounts

public A setToVolumeMounts(int index,
                           VolumeMounts item)

addToVolumeMounts

public A addToVolumeMounts(VolumeMounts... items)

addAllToVolumeMounts

public A addAllToVolumeMounts(Collection<VolumeMounts> items)

removeFromVolumeMounts

public A removeFromVolumeMounts(VolumeMounts... items)

removeAllFromVolumeMounts

public A removeAllFromVolumeMounts(Collection<VolumeMounts> items)

removeMatchingFromVolumeMounts

public A removeMatchingFromVolumeMounts(Predicate<VolumeMountsBuilder> predicate)

buildVolumeMounts

public List<VolumeMounts> buildVolumeMounts()

buildVolumeMount

public VolumeMounts buildVolumeMount(int index)

buildFirstVolumeMount

public VolumeMounts buildFirstVolumeMount()

buildLastVolumeMount

public VolumeMounts buildLastVolumeMount()

buildMatchingVolumeMount

public VolumeMounts buildMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)

hasMatchingVolumeMount

public boolean hasMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)

withVolumeMounts

public A withVolumeMounts(List<VolumeMounts> volumeMounts)

withVolumeMounts

public A withVolumeMounts(VolumeMounts... volumeMounts)

hasVolumeMounts
```
public boolean hasVolumeMounts()
```

addNewVolumeMount

public ContainersFluent.VolumeMountsNested<A> addNewVolumeMount()

addNewVolumeMountLike

public ContainersFluent.VolumeMountsNested<A> addNewVolumeMountLike(VolumeMounts item)

setNewVolumeMountLike

public ContainersFluent.VolumeMountsNested<A> setNewVolumeMountLike(int index,
                                                                    VolumeMounts item)

editVolumeMount

public ContainersFluent.VolumeMountsNested<A> editVolumeMount(int index)

editFirstVolumeMount

public ContainersFluent.VolumeMountsNested<A> editFirstVolumeMount()

editLastVolumeMount

public ContainersFluent.VolumeMountsNested<A> editLastVolumeMount()

editMatchingVolumeMount

public ContainersFluent.VolumeMountsNested<A> editMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)

getWorkingDir
```
public String getWorkingDir()
```

withWorkingDir

public A withWorkingDir(String workingDir)

hasWorkingDir
```
public boolean hasWorkingDir()
```

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

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

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

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

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

toString in class Object

withStdin
```
public A withStdin()
```

withStdinOnce
```
public A withStdinOnce()
```

withTty
```
public A withTty()
```

Constructors
Constructor	Description
`ContainersFluent()`
`ContainersFluent(Containers instance)`

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

ContainersFluent

ContainersFluent

Method Detail

addToArgs

setToArgs

addToArgs

addAllToArgs

removeFromArgs

removeAllFromArgs

getArgs

getArg

getFirstArg

getLastArg

getMatchingArg

hasMatchingArg

withArgs

withArgs

hasArgs

addToCommand

setToCommand

addToCommand

addAllToCommand

removeFromCommand

removeAllFromCommand

getCommand

getCommand

getFirstCommand

getLastCommand

getMatchingCommand

hasMatchingCommand

withCommand

withCommand

hasCommand

addToEnv

setToEnv

addToEnv

addAllToContainersEnv

removeFromEnv

removeAllFromContainersEnv

removeMatchingFromContainersEnv

buildEnv

buildEnv

buildFirstEnv

buildLastEnv

buildMatchingEnv

hasMatchingEnv

withEnv

withEnv

hasEnv

addNewContainersEnv

addNewEnvLike

setNewEnvLike

editEnv

editFirstEnv

editLastEnv

editMatchingEnv

addToEnvFrom

setToEnvFrom

addToEnvFrom

addAllToEnvFrom

removeFromEnvFrom

removeAllFromEnvFrom

removeMatchingFromEnvFrom

buildEnvFrom

buildEnvFrom

buildFirstEnvFrom

buildLastEnvFrom

buildMatchingEnvFrom

hasMatchingEnvFrom

withEnvFrom