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

All Implemented Interfaces:

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

Direct Known Subclasses:

EphemeralContainersBuilder, SpecFluent.EphemeralContainersNested
```
public class EphemeralContainersFluent<A extends EphemeralContainersFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersEnvNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersLifecycleNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersPortsNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersResourcesNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<N>`
`class`	`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<N>`

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

Constructor Summary

Constructors
Constructor Description

EphemeralContainersFluent()

EphemeralContainersFluent(EphemeralContainers 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`	`addAllToEphemeralcontainersEnv(Collection<Env> items)`
`A`	`addAllToEphemeralcontainersEnvFrom(Collection<EnvFrom> items)`
`A`	`addAllToEphemeralcontainersPorts(Collection<Ports> items)`
`A`	`addAllToEphemeralcontainersVolumeDevices(Collection<VolumeDevices> items)`
`A`	`addAllToEphemeralcontainersVolumeMounts(Collection<VolumeMounts> items)`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`addNewEnvFromLike(EnvFrom item)`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`addNewEnvLike(Env item)`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`addNewEphemeralcontainersEnv()`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`addNewEphemeralcontainersEnvFrom()`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`addNewEphemeralcontainersPort()`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`addNewEphemeralcontainersVolumeDevice()`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A>`	`addNewEphemeralcontainersVolumeMount()`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`addNewPortLike(Ports item)`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`addNewVolumeDeviceLike(VolumeDevices item)`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<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()`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`editEnv(int index)`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`editEnvFrom(int index)`
`EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A>`	`editEphemeralcontainersLifecycle()`
`EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A>`	`editEphemeralcontainersLivenessProbe()`
`EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A>`	`editEphemeralcontainersReadinessProbe()`
`EphemeralContainersFluent.EphemeralcontainersResourcesNested<A>`	`editEphemeralcontainersResources()`
`EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A>`	`editEphemeralcontainersSecurityContext()`
`EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A>`	`editEphemeralcontainersStartupProbe()`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`editFirstEnv()`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`editFirstEnvFrom()`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`editFirstPort()`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`editFirstVolumeDevice()`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A>`	`editFirstVolumeMount()`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`editLastEnv()`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`editLastEnvFrom()`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`editLastPort()`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`editLastVolumeDevice()`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A>`	`editLastVolumeMount()`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`editMatchingEnv(Predicate<EnvBuilder> predicate)`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`editMatchingEnvFrom(Predicate<EnvFromBuilder> predicate)`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`editMatchingPort(Predicate<PortsBuilder> predicate)`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`editMatchingVolumeDevice(Predicate<VolumeDevicesBuilder> predicate)`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A>`	`editMatchingVolumeMount(Predicate<VolumeMountsBuilder> predicate)`
`EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A>`	`editOrNewLifecycle()`
`EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A>`	`editOrNewLifecycleLike(Lifecycle item)`
`EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A>`	`editOrNewLivenessProbe()`
`EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A>`	`editOrNewLivenessProbeLike(LivenessProbe item)`
`EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A>`	`editOrNewReadinessProbe()`
`EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A>`	`editOrNewReadinessProbeLike(ReadinessProbe item)`
`EphemeralContainersFluent.EphemeralcontainersResourcesNested<A>`	`editOrNewResources()`
`EphemeralContainersFluent.EphemeralcontainersResourcesNested<A>`	`editOrNewResourcesLike(Resources item)`
`EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A>`	`editOrNewSecurityContext()`
`EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A>`	`editOrNewSecurityContextLike(SecurityContext item)`
`EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A>`	`editOrNewStartupProbe()`
`EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A>`	`editOrNewStartupProbeLike(StartupProbe item)`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`editPort(int index)`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`editVolumeDevice(int index)`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<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`	`getTargetContainerName()`
`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`	`hasTargetContainerName()`
`boolean`	`hasTerminationMessagePath()`
`boolean`	`hasTerminationMessagePolicy()`
`boolean`	`hasTty()`
`boolean`	`hasVolumeDevices()`
`boolean`	`hasVolumeMounts()`
`boolean`	`hasWorkingDir()`
`A`	`removeAllFromArgs(Collection<String> items)`
`A`	`removeAllFromCommand(Collection<String> items)`
`A`	`removeAllFromEphemeralcontainersEnv(Collection<Env> items)`
`A`	`removeAllFromEphemeralcontainersEnvFrom(Collection<EnvFrom> items)`
`A`	`removeAllFromEphemeralcontainersPorts(Collection<Ports> items)`
`A`	`removeAllFromEphemeralcontainersVolumeDevices(Collection<VolumeDevices> items)`
`A`	`removeAllFromEphemeralcontainersVolumeMounts(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`	`removeMatchingFromEphemeralcontainersEnv(Predicate<EnvBuilder> predicate)`
`A`	`removeMatchingFromEphemeralcontainersEnvFrom(Predicate<EnvFromBuilder> predicate)`
`A`	`removeMatchingFromEphemeralcontainersPorts(Predicate<PortsBuilder> predicate)`
`A`	`removeMatchingFromEphemeralcontainersVolumeDevices(Predicate<VolumeDevicesBuilder> predicate)`
`A`	`removeMatchingFromEphemeralcontainersVolumeMounts(Predicate<VolumeMountsBuilder> predicate)`
`EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A>`	`setNewEnvFromLike(int index, EnvFrom item)`
`EphemeralContainersFluent.EphemeralcontainersEnvNested<A>`	`setNewEnvLike(int index, Env item)`
`EphemeralContainersFluent.EphemeralcontainersPortsNested<A>`	`setNewPortLike(int index, Ports item)`
`EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A>`	`setNewVolumeDeviceLike(int index, VolumeDevices item)`
`EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<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)`
`EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A>`	`withNewEphemeralcontainersLifecycle()`
`EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A>`	`withNewEphemeralcontainersLivenessProbe()`
`EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A>`	`withNewEphemeralcontainersReadinessProbe()`
`EphemeralContainersFluent.EphemeralcontainersResourcesNested<A>`	`withNewEphemeralcontainersResources()`
`EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A>`	`withNewEphemeralcontainersSecurityContext()`
`EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A>`	`withNewEphemeralcontainersStartupProbe()`
`EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A>`	`withNewLifecycleLike(Lifecycle item)`
`EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A>`	`withNewLivenessProbeLike(LivenessProbe item)`
`EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A>`	`withNewReadinessProbeLike(ReadinessProbe item)`
`EphemeralContainersFluent.EphemeralcontainersResourcesNested<A>`	`withNewResourcesLike(Resources item)`
`EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A>`	`withNewSecurityContextLike(SecurityContext item)`
`EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<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`	`withTargetContainerName(String targetContainerName)`
`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

EphemeralContainersFluent
```
public EphemeralContainersFluent()
```

EphemeralContainersFluent

public EphemeralContainersFluent(EphemeralContainers 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)
```

addAllToEphemeralcontainersEnv

public A addAllToEphemeralcontainersEnv(Collection<Env> items)

removeFromEnv

public A removeFromEnv(Env... items)

removeAllFromEphemeralcontainersEnv

public A removeAllFromEphemeralcontainersEnv(Collection<Env> items)

removeMatchingFromEphemeralcontainersEnv

public A removeMatchingFromEphemeralcontainersEnv(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()
```

addNewEphemeralcontainersEnv

public EphemeralContainersFluent.EphemeralcontainersEnvNested<A> addNewEphemeralcontainersEnv()

addNewEnvLike

public EphemeralContainersFluent.EphemeralcontainersEnvNested<A> addNewEnvLike(Env item)

setNewEnvLike

public EphemeralContainersFluent.EphemeralcontainersEnvNested<A> setNewEnvLike(int index,
                                                                               Env item)

editEnv

public EphemeralContainersFluent.EphemeralcontainersEnvNested<A> editEnv(int index)

editFirstEnv

public EphemeralContainersFluent.EphemeralcontainersEnvNested<A> editFirstEnv()

editLastEnv

public EphemeralContainersFluent.EphemeralcontainersEnvNested<A> editLastEnv()

editMatchingEnv

public EphemeralContainersFluent.EphemeralcontainersEnvNested<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)

addAllToEphemeralcontainersEnvFrom

public A addAllToEphemeralcontainersEnvFrom(Collection<EnvFrom> items)

removeFromEnvFrom

public A removeFromEnvFrom(EnvFrom... items)

removeAllFromEphemeralcontainersEnvFrom

public A removeAllFromEphemeralcontainersEnvFrom(Collection<EnvFrom> items)

removeMatchingFromEphemeralcontainersEnvFrom

public A removeMatchingFromEphemeralcontainersEnvFrom(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()
```

addNewEphemeralcontainersEnvFrom

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A> addNewEphemeralcontainersEnvFrom()

addNewEnvFromLike

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A> addNewEnvFromLike(EnvFrom item)

setNewEnvFromLike

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A> setNewEnvFromLike(int index,
                                                                                       EnvFrom item)

editEnvFrom

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A> editEnvFrom(int index)

editFirstEnvFrom

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A> editFirstEnvFrom()

editLastEnvFrom

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<A> editLastEnvFrom()

editMatchingEnvFrom

public EphemeralContainersFluent.EphemeralcontainersEnvFromNested<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()
```

withNewEphemeralcontainersLifecycle

public EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A> withNewEphemeralcontainersLifecycle()

withNewLifecycleLike

public EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A> withNewLifecycleLike(Lifecycle item)

editEphemeralcontainersLifecycle

public EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A> editEphemeralcontainersLifecycle()

editOrNewLifecycle

public EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A> editOrNewLifecycle()

editOrNewLifecycleLike

public EphemeralContainersFluent.EphemeralcontainersLifecycleNested<A> editOrNewLifecycleLike(Lifecycle item)

buildLivenessProbe

public LivenessProbe buildLivenessProbe()

withLivenessProbe

public A withLivenessProbe(LivenessProbe livenessProbe)

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

withNewEphemeralcontainersLivenessProbe

public EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A> withNewEphemeralcontainersLivenessProbe()

withNewLivenessProbeLike

public EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A> withNewLivenessProbeLike(LivenessProbe item)

editEphemeralcontainersLivenessProbe

public EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A> editEphemeralcontainersLivenessProbe()

editOrNewLivenessProbe

public EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<A> editOrNewLivenessProbe()

editOrNewLivenessProbeLike

public EphemeralContainersFluent.EphemeralcontainersLivenessProbeNested<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)

addAllToEphemeralcontainersPorts

public A addAllToEphemeralcontainersPorts(Collection<Ports> items)

removeFromPorts

public A removeFromPorts(Ports... items)

removeAllFromEphemeralcontainersPorts

public A removeAllFromEphemeralcontainersPorts(Collection<Ports> items)

removeMatchingFromEphemeralcontainersPorts

public A removeMatchingFromEphemeralcontainersPorts(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()
```

addNewEphemeralcontainersPort

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> addNewEphemeralcontainersPort()

addNewPortLike

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> addNewPortLike(Ports item)

setNewPortLike

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> setNewPortLike(int index,
                                                                                  Ports item)

editPort

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> editPort(int index)

editFirstPort

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> editFirstPort()

editLastPort

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> editLastPort()

editMatchingPort

public EphemeralContainersFluent.EphemeralcontainersPortsNested<A> editMatchingPort(Predicate<PortsBuilder> predicate)

buildReadinessProbe

public ReadinessProbe buildReadinessProbe()

withReadinessProbe

public A withReadinessProbe(ReadinessProbe readinessProbe)

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

withNewEphemeralcontainersReadinessProbe

public EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A> withNewEphemeralcontainersReadinessProbe()

withNewReadinessProbeLike

public EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A> withNewReadinessProbeLike(ReadinessProbe item)

editEphemeralcontainersReadinessProbe

public EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A> editEphemeralcontainersReadinessProbe()

editOrNewReadinessProbe

public EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A> editOrNewReadinessProbe()

editOrNewReadinessProbeLike

public EphemeralContainersFluent.EphemeralcontainersReadinessProbeNested<A> editOrNewReadinessProbeLike(ReadinessProbe item)

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

withResources

public A withResources(Resources resources)

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

withNewEphemeralcontainersResources

public EphemeralContainersFluent.EphemeralcontainersResourcesNested<A> withNewEphemeralcontainersResources()

withNewResourcesLike

public EphemeralContainersFluent.EphemeralcontainersResourcesNested<A> withNewResourcesLike(Resources item)

editEphemeralcontainersResources

public EphemeralContainersFluent.EphemeralcontainersResourcesNested<A> editEphemeralcontainersResources()

editOrNewResources

public EphemeralContainersFluent.EphemeralcontainersResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public EphemeralContainersFluent.EphemeralcontainersResourcesNested<A> editOrNewResourcesLike(Resources item)

buildSecurityContext

public SecurityContext buildSecurityContext()

withSecurityContext

public A withSecurityContext(SecurityContext securityContext)

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

withNewEphemeralcontainersSecurityContext

public EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A> withNewEphemeralcontainersSecurityContext()

withNewSecurityContextLike

public EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A> withNewSecurityContextLike(SecurityContext item)

editEphemeralcontainersSecurityContext

public EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A> editEphemeralcontainersSecurityContext()

editOrNewSecurityContext

public EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A> editOrNewSecurityContext()

editOrNewSecurityContextLike

public EphemeralContainersFluent.EphemeralcontainersSecurityContextNested<A> editOrNewSecurityContextLike(SecurityContext item)

buildStartupProbe

public StartupProbe buildStartupProbe()

withStartupProbe

public A withStartupProbe(StartupProbe startupProbe)

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

withNewEphemeralcontainersStartupProbe

public EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A> withNewEphemeralcontainersStartupProbe()

withNewStartupProbeLike

public EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A> withNewStartupProbeLike(StartupProbe item)

editEphemeralcontainersStartupProbe

public EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A> editEphemeralcontainersStartupProbe()

editOrNewStartupProbe

public EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<A> editOrNewStartupProbe()

editOrNewStartupProbeLike

public EphemeralContainersFluent.EphemeralcontainersStartupProbeNested<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()
```

getTargetContainerName

public String getTargetContainerName()

withTargetContainerName

public A withTargetContainerName(String targetContainerName)

hasTargetContainerName

public boolean hasTargetContainerName()

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)

addAllToEphemeralcontainersVolumeDevices

public A addAllToEphemeralcontainersVolumeDevices(Collection<VolumeDevices> items)

removeFromVolumeDevices

public A removeFromVolumeDevices(VolumeDevices... items)

removeAllFromEphemeralcontainersVolumeDevices

public A removeAllFromEphemeralcontainersVolumeDevices(Collection<VolumeDevices> items)

removeMatchingFromEphemeralcontainersVolumeDevices

public A removeMatchingFromEphemeralcontainersVolumeDevices(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()
```

addNewEphemeralcontainersVolumeDevice

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A> addNewEphemeralcontainersVolumeDevice()

addNewVolumeDeviceLike

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A> addNewVolumeDeviceLike(VolumeDevices item)

setNewVolumeDeviceLike

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A> setNewVolumeDeviceLike(int index,
                                                                                                  VolumeDevices item)

editVolumeDevice

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A> editVolumeDevice(int index)

editFirstVolumeDevice

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A> editFirstVolumeDevice()

editLastVolumeDevice

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<A> editLastVolumeDevice()

editMatchingVolumeDevice

public EphemeralContainersFluent.EphemeralcontainersVolumeDevicesNested<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)

addAllToEphemeralcontainersVolumeMounts

public A addAllToEphemeralcontainersVolumeMounts(Collection<VolumeMounts> items)

removeFromVolumeMounts

public A removeFromVolumeMounts(VolumeMounts... items)

removeAllFromEphemeralcontainersVolumeMounts

public A removeAllFromEphemeralcontainersVolumeMounts(Collection<VolumeMounts> items)

removeMatchingFromEphemeralcontainersVolumeMounts

public A removeMatchingFromEphemeralcontainersVolumeMounts(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()
```

addNewEphemeralcontainersVolumeMount

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A> addNewEphemeralcontainersVolumeMount()

addNewVolumeMountLike

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A> addNewVolumeMountLike(VolumeMounts item)

setNewVolumeMountLike

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A> setNewVolumeMountLike(int index,
                                                                                                VolumeMounts item)

editVolumeMount

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A> editVolumeMount(int index)

editFirstVolumeMount

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A> editFirstVolumeMount()

editLastVolumeMount

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<A> editLastVolumeMount()

editMatchingVolumeMount

public EphemeralContainersFluent.EphemeralcontainersVolumeMountsNested<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 EphemeralContainersFluent<A>>

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

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

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

toString in class Object

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

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

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

Constructor	Description
`EphemeralContainersFluent()`
`EphemeralContainersFluent(EphemeralContainers instance)`

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

EphemeralContainersFluent

EphemeralContainersFluent

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

addAllToEphemeralcontainersEnv

removeFromEnv

removeAllFromEphemeralcontainersEnv

removeMatchingFromEphemeralcontainersEnv

buildEnv

buildEnv

buildFirstEnv

buildLastEnv

buildMatchingEnv

hasMatchingEnv

withEnv

withEnv

hasEnv

addNewEphemeralcontainersEnv

addNewEnvLike

setNewEnvLike

editEnv

editFirstEnv

editLastEnv

editMatchingEnv

addToEnvFrom

setToEnvFrom

addToEnvFrom

addAllToEphemeralcontainersEnvFrom

removeFromEnvFrom

removeAllFromEphemeralcontainersEnvFrom

removeMatchingFromEphemeralcontainersEnvFrom

buildEnvFrom

buildEnvFrom

buildFirstEnvFrom

buildLastEnvFrom

buildMatchingEnvFrom

hasMatchingEnvFrom

withEnvFrom