java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.openshift.api.model.miscellaneous.metal3.v1beta1.MetaDataFluent<A>

Direct Known Subclasses:: MetaDataBuilder, Metal3DataTemplateSpecFluent.MetaDataNested

public class MetaDataFluent<A extends MetaDataFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>

Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`MetaDataFluent.DnsServersFromIPPoolNested<N>`
`class`	`MetaDataFluent.FromAnnotationsNested<N>`
`class`	`MetaDataFluent.FromHostInterfacesNested<N>`
`class`	`MetaDataFluent.FromLabelsNested<N>`
`class`	`MetaDataFluent.GatewaysFromIPPoolNested<N>`
`class`	`MetaDataFluent.IndexesNested<N>`
`class`	`MetaDataFluent.IpAddressesFromIPPoolNested<N>`
`class`	`MetaDataFluent.NamespacesNested<N>`
`class`	`MetaDataFluent.ObjectNamesNested<N>`
`class`	`MetaDataFluent.PrefixesFromIPPoolNested<N>`
`class`	`MetaDataFluent.StringsNested<N>`

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

Constructor Summary

Constructors
Constructor Description

MetaDataFluent()

MetaDataFluent(MetaData instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToDnsServersFromIPPool(Collection<FromPool> items)`
`A`	`addAllToFromAnnotations(Collection<MetaDataFromAnnotation> items)`
`A`	`addAllToFromHostInterfaces(Collection<MetaDataHostInterface> items)`
`A`	`addAllToFromLabels(Collection<MetaDataFromLabel> items)`
`A`	`addAllToGatewaysFromIPPool(Collection<FromPool> items)`
`A`	`addAllToIndexes(Collection<MetaDataIndex> items)`
`A`	`addAllToIpAddressesFromIPPool(Collection<FromPool> items)`
`A`	`addAllToNamespaces(Collection<MetaDataNamespace> items)`
`A`	`addAllToObjectNames(Collection<MetaDataObjectName> items)`
`A`	`addAllToPrefixesFromIPPool(Collection<FromPool> items)`
`A`	`addAllToStrings(Collection<MetaDataString> items)`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`addNewDnsServersFromIPPool()`
`A`	`addNewDnsServersFromIPPool(String apiGroup, String key, String kind, String name)`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`addNewDnsServersFromIPPoolLike(FromPool item)`
`MetaDataFluent.FromAnnotationsNested<A>`	`addNewFromAnnotation()`
`A`	`addNewFromAnnotation(String annotation, String key, String object)`
`MetaDataFluent.FromAnnotationsNested<A>`	`addNewFromAnnotationLike(MetaDataFromAnnotation item)`
`MetaDataFluent.FromHostInterfacesNested<A>`	`addNewFromHostInterface()`
`A`	`addNewFromHostInterface(String _interface, String key)`
`MetaDataFluent.FromHostInterfacesNested<A>`	`addNewFromHostInterfaceLike(MetaDataHostInterface item)`
`MetaDataFluent.FromLabelsNested<A>`	`addNewFromLabel()`
`A`	`addNewFromLabel(String key, String label, String object)`
`MetaDataFluent.FromLabelsNested<A>`	`addNewFromLabelLike(MetaDataFromLabel item)`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`addNewGatewaysFromIPPool()`
`A`	`addNewGatewaysFromIPPool(String apiGroup, String key, String kind, String name)`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`addNewGatewaysFromIPPoolLike(FromPool item)`
`MetaDataFluent.IndexesNested<A>`	`addNewIndex()`
`A`	`addNewIndex(String key, Integer offset, String prefix, Integer step, String suffix)`
`MetaDataFluent.IndexesNested<A>`	`addNewIndexLike(MetaDataIndex item)`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`addNewIpAddressesFromIPPool()`
`A`	`addNewIpAddressesFromIPPool(String apiGroup, String key, String kind, String name)`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`addNewIpAddressesFromIPPoolLike(FromPool item)`
`MetaDataFluent.NamespacesNested<A>`	`addNewNamespace()`
`A`	`addNewNamespace(String key)`
`MetaDataFluent.NamespacesNested<A>`	`addNewNamespaceLike(MetaDataNamespace item)`
`MetaDataFluent.ObjectNamesNested<A>`	`addNewObjectName()`
`A`	`addNewObjectName(String key, String object)`
`MetaDataFluent.ObjectNamesNested<A>`	`addNewObjectNameLike(MetaDataObjectName item)`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`addNewPrefixesFromIPPool()`
`A`	`addNewPrefixesFromIPPool(String apiGroup, String key, String kind, String name)`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`addNewPrefixesFromIPPoolLike(FromPool item)`
`MetaDataFluent.StringsNested<A>`	`addNewString()`
`A`	`addNewString(String key, String value)`
`MetaDataFluent.StringsNested<A>`	`addNewStringLike(MetaDataString item)`
`A`	`addToAdditionalProperties(String key, Object value)`
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToDnsServersFromIPPool(int index, FromPool item)`
`A`	`addToDnsServersFromIPPool(FromPool... items)`
`A`	`addToFromAnnotations(int index, MetaDataFromAnnotation item)`
`A`	`addToFromAnnotations(MetaDataFromAnnotation... items)`
`A`	`addToFromHostInterfaces(int index, MetaDataHostInterface item)`
`A`	`addToFromHostInterfaces(MetaDataHostInterface... items)`
`A`	`addToFromLabels(int index, MetaDataFromLabel item)`
`A`	`addToFromLabels(MetaDataFromLabel... items)`
`A`	`addToGatewaysFromIPPool(int index, FromPool item)`
`A`	`addToGatewaysFromIPPool(FromPool... items)`
`A`	`addToIndexes(int index, MetaDataIndex item)`
`A`	`addToIndexes(MetaDataIndex... items)`
`A`	`addToIpAddressesFromIPPool(int index, FromPool item)`
`A`	`addToIpAddressesFromIPPool(FromPool... items)`
`A`	`addToNamespaces(int index, MetaDataNamespace item)`
`A`	`addToNamespaces(MetaDataNamespace... items)`
`A`	`addToObjectNames(int index, MetaDataObjectName item)`
`A`	`addToObjectNames(MetaDataObjectName... items)`
`A`	`addToPrefixesFromIPPool(int index, FromPool item)`
`A`	`addToPrefixesFromIPPool(FromPool... items)`
`A`	`addToStrings(int index, MetaDataString item)`
`A`	`addToStrings(MetaDataString... items)`
`List<FromPool>`	`buildDnsServersFromIPPool()`
`FromPool`	`buildDnsServersFromIPPool(int index)`
`FromPool`	`buildFirstDnsServersFromIPPool()`
`MetaDataFromAnnotation`	`buildFirstFromAnnotation()`
`MetaDataHostInterface`	`buildFirstFromHostInterface()`
`MetaDataFromLabel`	`buildFirstFromLabel()`
`FromPool`	`buildFirstGatewaysFromIPPool()`
`MetaDataIndex`	`buildFirstIndex()`
`FromPool`	`buildFirstIpAddressesFromIPPool()`
`MetaDataNamespace`	`buildFirstNamespace()`
`MetaDataObjectName`	`buildFirstObjectName()`
`FromPool`	`buildFirstPrefixesFromIPPool()`
`MetaDataString`	`buildFirstString()`
`MetaDataFromAnnotation`	`buildFromAnnotation(int index)`
`List<MetaDataFromAnnotation>`	`buildFromAnnotations()`
`MetaDataHostInterface`	`buildFromHostInterface(int index)`
`List<MetaDataHostInterface>`	`buildFromHostInterfaces()`
`MetaDataFromLabel`	`buildFromLabel(int index)`
`List<MetaDataFromLabel>`	`buildFromLabels()`
`List<FromPool>`	`buildGatewaysFromIPPool()`
`FromPool`	`buildGatewaysFromIPPool(int index)`
`MetaDataIndex`	`buildIndex(int index)`
`List<MetaDataIndex>`	`buildIndexes()`
`List<FromPool>`	`buildIpAddressesFromIPPool()`
`FromPool`	`buildIpAddressesFromIPPool(int index)`
`FromPool`	`buildLastDnsServersFromIPPool()`
`MetaDataFromAnnotation`	`buildLastFromAnnotation()`
`MetaDataHostInterface`	`buildLastFromHostInterface()`
`MetaDataFromLabel`	`buildLastFromLabel()`
`FromPool`	`buildLastGatewaysFromIPPool()`
`MetaDataIndex`	`buildLastIndex()`
`FromPool`	`buildLastIpAddressesFromIPPool()`
`MetaDataNamespace`	`buildLastNamespace()`
`MetaDataObjectName`	`buildLastObjectName()`
`FromPool`	`buildLastPrefixesFromIPPool()`
`MetaDataString`	`buildLastString()`
`FromPool`	`buildMatchingDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataFromAnnotation`	`buildMatchingFromAnnotation(Predicate<MetaDataFromAnnotationBuilder> predicate)`
`MetaDataHostInterface`	`buildMatchingFromHostInterface(Predicate<MetaDataHostInterfaceBuilder> predicate)`
`MetaDataFromLabel`	`buildMatchingFromLabel(Predicate<MetaDataFromLabelBuilder> predicate)`
`FromPool`	`buildMatchingGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataIndex`	`buildMatchingIndex(Predicate<MetaDataIndexBuilder> predicate)`
`FromPool`	`buildMatchingIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataNamespace`	`buildMatchingNamespace(Predicate<MetaDataNamespaceBuilder> predicate)`
`MetaDataObjectName`	`buildMatchingObjectName(Predicate<MetaDataObjectNameBuilder> predicate)`
`FromPool`	`buildMatchingPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataString`	`buildMatchingString(Predicate<MetaDataStringBuilder> predicate)`
`MetaDataNamespace`	`buildNamespace(int index)`
`List<MetaDataNamespace>`	`buildNamespaces()`
`MetaDataObjectName`	`buildObjectName(int index)`
`List<MetaDataObjectName>`	`buildObjectNames()`
`List<FromPool>`	`buildPrefixesFromIPPool()`
`FromPool`	`buildPrefixesFromIPPool(int index)`
`MetaDataString`	`buildString(int index)`
`List<MetaDataString>`	`buildStrings()`
`protected void`	`copyInstance(MetaData instance)`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`editDnsServersFromIPPool(int index)`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`editFirstDnsServersFromIPPool()`
`MetaDataFluent.FromAnnotationsNested<A>`	`editFirstFromAnnotation()`
`MetaDataFluent.FromHostInterfacesNested<A>`	`editFirstFromHostInterface()`
`MetaDataFluent.FromLabelsNested<A>`	`editFirstFromLabel()`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`editFirstGatewaysFromIPPool()`
`MetaDataFluent.IndexesNested<A>`	`editFirstIndex()`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`editFirstIpAddressesFromIPPool()`
`MetaDataFluent.NamespacesNested<A>`	`editFirstNamespace()`
`MetaDataFluent.ObjectNamesNested<A>`	`editFirstObjectName()`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`editFirstPrefixesFromIPPool()`
`MetaDataFluent.StringsNested<A>`	`editFirstString()`
`MetaDataFluent.FromAnnotationsNested<A>`	`editFromAnnotation(int index)`
`MetaDataFluent.FromHostInterfacesNested<A>`	`editFromHostInterface(int index)`
`MetaDataFluent.FromLabelsNested<A>`	`editFromLabel(int index)`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`editGatewaysFromIPPool(int index)`
`MetaDataFluent.IndexesNested<A>`	`editIndex(int index)`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`editIpAddressesFromIPPool(int index)`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`editLastDnsServersFromIPPool()`
`MetaDataFluent.FromAnnotationsNested<A>`	`editLastFromAnnotation()`
`MetaDataFluent.FromHostInterfacesNested<A>`	`editLastFromHostInterface()`
`MetaDataFluent.FromLabelsNested<A>`	`editLastFromLabel()`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`editLastGatewaysFromIPPool()`
`MetaDataFluent.IndexesNested<A>`	`editLastIndex()`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`editLastIpAddressesFromIPPool()`
`MetaDataFluent.NamespacesNested<A>`	`editLastNamespace()`
`MetaDataFluent.ObjectNamesNested<A>`	`editLastObjectName()`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`editLastPrefixesFromIPPool()`
`MetaDataFluent.StringsNested<A>`	`editLastString()`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`editMatchingDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataFluent.FromAnnotationsNested<A>`	`editMatchingFromAnnotation(Predicate<MetaDataFromAnnotationBuilder> predicate)`
`MetaDataFluent.FromHostInterfacesNested<A>`	`editMatchingFromHostInterface(Predicate<MetaDataHostInterfaceBuilder> predicate)`
`MetaDataFluent.FromLabelsNested<A>`	`editMatchingFromLabel(Predicate<MetaDataFromLabelBuilder> predicate)`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`editMatchingGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataFluent.IndexesNested<A>`	`editMatchingIndex(Predicate<MetaDataIndexBuilder> predicate)`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`editMatchingIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataFluent.NamespacesNested<A>`	`editMatchingNamespace(Predicate<MetaDataNamespaceBuilder> predicate)`
`MetaDataFluent.ObjectNamesNested<A>`	`editMatchingObjectName(Predicate<MetaDataObjectNameBuilder> predicate)`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`editMatchingPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`MetaDataFluent.StringsNested<A>`	`editMatchingString(Predicate<MetaDataStringBuilder> predicate)`
`MetaDataFluent.NamespacesNested<A>`	`editNamespace(int index)`
`MetaDataFluent.ObjectNamesNested<A>`	`editObjectName(int index)`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`editPrefixesFromIPPool(int index)`
`MetaDataFluent.StringsNested<A>`	`editString(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasDnsServersFromIPPool()`
`boolean`	`hasFromAnnotations()`
`boolean`	`hasFromHostInterfaces()`
`boolean`	`hasFromLabels()`
`boolean`	`hasGatewaysFromIPPool()`
`int`	`hashCode()`
`boolean`	`hasIndexes()`
`boolean`	`hasIpAddressesFromIPPool()`
`boolean`	`hasMatchingDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)`
`boolean`	`hasMatchingFromAnnotation(Predicate<MetaDataFromAnnotationBuilder> predicate)`
`boolean`	`hasMatchingFromHostInterface(Predicate<MetaDataHostInterfaceBuilder> predicate)`
`boolean`	`hasMatchingFromLabel(Predicate<MetaDataFromLabelBuilder> predicate)`
`boolean`	`hasMatchingGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)`
`boolean`	`hasMatchingIndex(Predicate<MetaDataIndexBuilder> predicate)`
`boolean`	`hasMatchingIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`boolean`	`hasMatchingNamespace(Predicate<MetaDataNamespaceBuilder> predicate)`
`boolean`	`hasMatchingObjectName(Predicate<MetaDataObjectNameBuilder> predicate)`
`boolean`	`hasMatchingPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`boolean`	`hasMatchingString(Predicate<MetaDataStringBuilder> predicate)`
`boolean`	`hasNamespaces()`
`boolean`	`hasObjectNames()`
`boolean`	`hasPrefixesFromIPPool()`
`boolean`	`hasStrings()`
`A`	`removeAllFromDnsServersFromIPPool(Collection<FromPool> items)`
`A`	`removeAllFromFromAnnotations(Collection<MetaDataFromAnnotation> items)`
`A`	`removeAllFromFromHostInterfaces(Collection<MetaDataHostInterface> items)`
`A`	`removeAllFromFromLabels(Collection<MetaDataFromLabel> items)`
`A`	`removeAllFromGatewaysFromIPPool(Collection<FromPool> items)`
`A`	`removeAllFromIndexes(Collection<MetaDataIndex> items)`
`A`	`removeAllFromIpAddressesFromIPPool(Collection<FromPool> items)`
`A`	`removeAllFromNamespaces(Collection<MetaDataNamespace> items)`
`A`	`removeAllFromObjectNames(Collection<MetaDataObjectName> items)`
`A`	`removeAllFromPrefixesFromIPPool(Collection<FromPool> items)`
`A`	`removeAllFromStrings(Collection<MetaDataString> items)`
`A`	`removeFromAdditionalProperties(String key)`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromDnsServersFromIPPool(FromPool... items)`
`A`	`removeFromFromAnnotations(MetaDataFromAnnotation... items)`
`A`	`removeFromFromHostInterfaces(MetaDataHostInterface... items)`
`A`	`removeFromFromLabels(MetaDataFromLabel... items)`
`A`	`removeFromGatewaysFromIPPool(FromPool... items)`
`A`	`removeFromIndexes(MetaDataIndex... items)`
`A`	`removeFromIpAddressesFromIPPool(FromPool... items)`
`A`	`removeFromNamespaces(MetaDataNamespace... items)`
`A`	`removeFromObjectNames(MetaDataObjectName... items)`
`A`	`removeFromPrefixesFromIPPool(FromPool... items)`
`A`	`removeFromStrings(MetaDataString... items)`
`A`	`removeMatchingFromDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)`
`A`	`removeMatchingFromFromAnnotations(Predicate<MetaDataFromAnnotationBuilder> predicate)`
`A`	`removeMatchingFromFromHostInterfaces(Predicate<MetaDataHostInterfaceBuilder> predicate)`
`A`	`removeMatchingFromFromLabels(Predicate<MetaDataFromLabelBuilder> predicate)`
`A`	`removeMatchingFromGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)`
`A`	`removeMatchingFromIndexes(Predicate<MetaDataIndexBuilder> predicate)`
`A`	`removeMatchingFromIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`A`	`removeMatchingFromNamespaces(Predicate<MetaDataNamespaceBuilder> predicate)`
`A`	`removeMatchingFromObjectNames(Predicate<MetaDataObjectNameBuilder> predicate)`
`A`	`removeMatchingFromPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)`
`A`	`removeMatchingFromStrings(Predicate<MetaDataStringBuilder> predicate)`
`MetaDataFluent.DnsServersFromIPPoolNested<A>`	`setNewDnsServersFromIPPoolLike(int index, FromPool item)`
`MetaDataFluent.FromAnnotationsNested<A>`	`setNewFromAnnotationLike(int index, MetaDataFromAnnotation item)`
`MetaDataFluent.FromHostInterfacesNested<A>`	`setNewFromHostInterfaceLike(int index, MetaDataHostInterface item)`
`MetaDataFluent.FromLabelsNested<A>`	`setNewFromLabelLike(int index, MetaDataFromLabel item)`
`MetaDataFluent.GatewaysFromIPPoolNested<A>`	`setNewGatewaysFromIPPoolLike(int index, FromPool item)`
`MetaDataFluent.IndexesNested<A>`	`setNewIndexLike(int index, MetaDataIndex item)`
`MetaDataFluent.IpAddressesFromIPPoolNested<A>`	`setNewIpAddressesFromIPPoolLike(int index, FromPool item)`
`MetaDataFluent.NamespacesNested<A>`	`setNewNamespaceLike(int index, MetaDataNamespace item)`
`MetaDataFluent.ObjectNamesNested<A>`	`setNewObjectNameLike(int index, MetaDataObjectName item)`
`MetaDataFluent.PrefixesFromIPPoolNested<A>`	`setNewPrefixesFromIPPoolLike(int index, FromPool item)`
`MetaDataFluent.StringsNested<A>`	`setNewStringLike(int index, MetaDataString item)`
`A`	`setToDnsServersFromIPPool(int index, FromPool item)`
`A`	`setToFromAnnotations(int index, MetaDataFromAnnotation item)`
`A`	`setToFromHostInterfaces(int index, MetaDataHostInterface item)`
`A`	`setToFromLabels(int index, MetaDataFromLabel item)`
`A`	`setToGatewaysFromIPPool(int index, FromPool item)`
`A`	`setToIndexes(int index, MetaDataIndex item)`
`A`	`setToIpAddressesFromIPPool(int index, FromPool item)`
`A`	`setToNamespaces(int index, MetaDataNamespace item)`
`A`	`setToObjectNames(int index, MetaDataObjectName item)`
`A`	`setToPrefixesFromIPPool(int index, FromPool item)`
`A`	`setToStrings(int index, MetaDataString item)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withDnsServersFromIPPool(FromPool... dnsServersFromIPPool)`
`A`	`withDnsServersFromIPPool(List<FromPool> dnsServersFromIPPool)`
`A`	`withFromAnnotations(MetaDataFromAnnotation... fromAnnotations)`
`A`	`withFromAnnotations(List<MetaDataFromAnnotation> fromAnnotations)`
`A`	`withFromHostInterfaces(MetaDataHostInterface... fromHostInterfaces)`
`A`	`withFromHostInterfaces(List<MetaDataHostInterface> fromHostInterfaces)`
`A`	`withFromLabels(MetaDataFromLabel... fromLabels)`
`A`	`withFromLabels(List<MetaDataFromLabel> fromLabels)`
`A`	`withGatewaysFromIPPool(FromPool... gatewaysFromIPPool)`
`A`	`withGatewaysFromIPPool(List<FromPool> gatewaysFromIPPool)`
`A`	`withIndexes(MetaDataIndex... indexes)`
`A`	`withIndexes(List<MetaDataIndex> indexes)`
`A`	`withIpAddressesFromIPPool(FromPool... ipAddressesFromIPPool)`
`A`	`withIpAddressesFromIPPool(List<FromPool> ipAddressesFromIPPool)`
`A`	`withNamespaces(MetaDataNamespace... namespaces)`
`A`	`withNamespaces(List<MetaDataNamespace> namespaces)`
`A`	`withObjectNames(MetaDataObjectName... objectNames)`
`A`	`withObjectNames(List<MetaDataObjectName> objectNames)`
`A`	`withPrefixesFromIPPool(FromPool... prefixesFromIPPool)`
`A`	`withPrefixesFromIPPool(List<FromPool> prefixesFromIPPool)`
`A`	`withStrings(MetaDataString... strings)`
`A`	`withStrings(List<MetaDataString> strings)`

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

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

Constructor Detail

MetaDataFluent
```
public MetaDataFluent()
```

MetaDataFluent

public MetaDataFluent(MetaData instance)

Method Detail

copyInstance

protected void copyInstance(MetaData instance)

addToDnsServersFromIPPool

public A addToDnsServersFromIPPool(int index,
                                   FromPool item)

setToDnsServersFromIPPool

public A setToDnsServersFromIPPool(int index,
                                   FromPool item)

addToDnsServersFromIPPool

public A addToDnsServersFromIPPool(FromPool... items)

addAllToDnsServersFromIPPool

public A addAllToDnsServersFromIPPool(Collection<FromPool> items)

removeFromDnsServersFromIPPool

public A removeFromDnsServersFromIPPool(FromPool... items)

removeAllFromDnsServersFromIPPool

public A removeAllFromDnsServersFromIPPool(Collection<FromPool> items)

removeMatchingFromDnsServersFromIPPool

public A removeMatchingFromDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)

buildDnsServersFromIPPool

public List<FromPool> buildDnsServersFromIPPool()

buildDnsServersFromIPPool

public FromPool buildDnsServersFromIPPool(int index)

buildFirstDnsServersFromIPPool

public FromPool buildFirstDnsServersFromIPPool()

buildLastDnsServersFromIPPool

public FromPool buildLastDnsServersFromIPPool()

buildMatchingDnsServersFromIPPool

public FromPool buildMatchingDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)

hasMatchingDnsServersFromIPPool

public boolean hasMatchingDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)

withDnsServersFromIPPool

public A withDnsServersFromIPPool(List<FromPool> dnsServersFromIPPool)

withDnsServersFromIPPool

public A withDnsServersFromIPPool(FromPool... dnsServersFromIPPool)

hasDnsServersFromIPPool

public boolean hasDnsServersFromIPPool()

addNewDnsServersFromIPPool

public A addNewDnsServersFromIPPool(String apiGroup,
                                    String key,
                                    String kind,
                                    String name)

addNewDnsServersFromIPPool

public MetaDataFluent.DnsServersFromIPPoolNested<A> addNewDnsServersFromIPPool()

addNewDnsServersFromIPPoolLike

public MetaDataFluent.DnsServersFromIPPoolNested<A> addNewDnsServersFromIPPoolLike(FromPool item)

setNewDnsServersFromIPPoolLike

public MetaDataFluent.DnsServersFromIPPoolNested<A> setNewDnsServersFromIPPoolLike(int index,
                                                                                   FromPool item)

editDnsServersFromIPPool

public MetaDataFluent.DnsServersFromIPPoolNested<A> editDnsServersFromIPPool(int index)

editFirstDnsServersFromIPPool

public MetaDataFluent.DnsServersFromIPPoolNested<A> editFirstDnsServersFromIPPool()

editLastDnsServersFromIPPool

public MetaDataFluent.DnsServersFromIPPoolNested<A> editLastDnsServersFromIPPool()

editMatchingDnsServersFromIPPool

public MetaDataFluent.DnsServersFromIPPoolNested<A> editMatchingDnsServersFromIPPool(Predicate<FromPoolBuilder> predicate)

addToFromAnnotations

public A addToFromAnnotations(int index,
                              MetaDataFromAnnotation item)

setToFromAnnotations

public A setToFromAnnotations(int index,
                              MetaDataFromAnnotation item)

addToFromAnnotations

public A addToFromAnnotations(MetaDataFromAnnotation... items)

addAllToFromAnnotations

public A addAllToFromAnnotations(Collection<MetaDataFromAnnotation> items)

removeFromFromAnnotations

public A removeFromFromAnnotations(MetaDataFromAnnotation... items)

removeAllFromFromAnnotations

public A removeAllFromFromAnnotations(Collection<MetaDataFromAnnotation> items)

removeMatchingFromFromAnnotations

public A removeMatchingFromFromAnnotations(Predicate<MetaDataFromAnnotationBuilder> predicate)

buildFromAnnotations

public List<MetaDataFromAnnotation> buildFromAnnotations()

buildFromAnnotation

public MetaDataFromAnnotation buildFromAnnotation(int index)

buildFirstFromAnnotation

public MetaDataFromAnnotation buildFirstFromAnnotation()

buildLastFromAnnotation

public MetaDataFromAnnotation buildLastFromAnnotation()

buildMatchingFromAnnotation

public MetaDataFromAnnotation buildMatchingFromAnnotation(Predicate<MetaDataFromAnnotationBuilder> predicate)

hasMatchingFromAnnotation

public boolean hasMatchingFromAnnotation(Predicate<MetaDataFromAnnotationBuilder> predicate)

withFromAnnotations

public A withFromAnnotations(List<MetaDataFromAnnotation> fromAnnotations)

withFromAnnotations

public A withFromAnnotations(MetaDataFromAnnotation... fromAnnotations)

hasFromAnnotations
```
public boolean hasFromAnnotations()
```

addNewFromAnnotation

public A addNewFromAnnotation(String annotation,
                              String key,
                              String object)

addNewFromAnnotation

public MetaDataFluent.FromAnnotationsNested<A> addNewFromAnnotation()

addNewFromAnnotationLike

public MetaDataFluent.FromAnnotationsNested<A> addNewFromAnnotationLike(MetaDataFromAnnotation item)

setNewFromAnnotationLike

public MetaDataFluent.FromAnnotationsNested<A> setNewFromAnnotationLike(int index,
                                                                        MetaDataFromAnnotation item)

editFromAnnotation

public MetaDataFluent.FromAnnotationsNested<A> editFromAnnotation(int index)

editFirstFromAnnotation

public MetaDataFluent.FromAnnotationsNested<A> editFirstFromAnnotation()

editLastFromAnnotation

public MetaDataFluent.FromAnnotationsNested<A> editLastFromAnnotation()

editMatchingFromAnnotation

public MetaDataFluent.FromAnnotationsNested<A> editMatchingFromAnnotation(Predicate<MetaDataFromAnnotationBuilder> predicate)

addToFromHostInterfaces

public A addToFromHostInterfaces(int index,
                                 MetaDataHostInterface item)

setToFromHostInterfaces

public A setToFromHostInterfaces(int index,
                                 MetaDataHostInterface item)

addToFromHostInterfaces

public A addToFromHostInterfaces(MetaDataHostInterface... items)

addAllToFromHostInterfaces

public A addAllToFromHostInterfaces(Collection<MetaDataHostInterface> items)

removeFromFromHostInterfaces

public A removeFromFromHostInterfaces(MetaDataHostInterface... items)

removeAllFromFromHostInterfaces

public A removeAllFromFromHostInterfaces(Collection<MetaDataHostInterface> items)

removeMatchingFromFromHostInterfaces

public A removeMatchingFromFromHostInterfaces(Predicate<MetaDataHostInterfaceBuilder> predicate)

buildFromHostInterfaces

public List<MetaDataHostInterface> buildFromHostInterfaces()

buildFromHostInterface

public MetaDataHostInterface buildFromHostInterface(int index)

buildFirstFromHostInterface

public MetaDataHostInterface buildFirstFromHostInterface()

buildLastFromHostInterface

public MetaDataHostInterface buildLastFromHostInterface()

buildMatchingFromHostInterface

public MetaDataHostInterface buildMatchingFromHostInterface(Predicate<MetaDataHostInterfaceBuilder> predicate)

hasMatchingFromHostInterface

public boolean hasMatchingFromHostInterface(Predicate<MetaDataHostInterfaceBuilder> predicate)

withFromHostInterfaces

public A withFromHostInterfaces(List<MetaDataHostInterface> fromHostInterfaces)

withFromHostInterfaces

public A withFromHostInterfaces(MetaDataHostInterface... fromHostInterfaces)

hasFromHostInterfaces

public boolean hasFromHostInterfaces()

addNewFromHostInterface

public A addNewFromHostInterface(String _interface,
                                 String key)

addNewFromHostInterface

public MetaDataFluent.FromHostInterfacesNested<A> addNewFromHostInterface()

addNewFromHostInterfaceLike

public MetaDataFluent.FromHostInterfacesNested<A> addNewFromHostInterfaceLike(MetaDataHostInterface item)

setNewFromHostInterfaceLike

public MetaDataFluent.FromHostInterfacesNested<A> setNewFromHostInterfaceLike(int index,
                                                                              MetaDataHostInterface item)

editFromHostInterface

public MetaDataFluent.FromHostInterfacesNested<A> editFromHostInterface(int index)

editFirstFromHostInterface

public MetaDataFluent.FromHostInterfacesNested<A> editFirstFromHostInterface()

editLastFromHostInterface

public MetaDataFluent.FromHostInterfacesNested<A> editLastFromHostInterface()

editMatchingFromHostInterface

public MetaDataFluent.FromHostInterfacesNested<A> editMatchingFromHostInterface(Predicate<MetaDataHostInterfaceBuilder> predicate)

addToFromLabels

public A addToFromLabels(int index,
                         MetaDataFromLabel item)

setToFromLabels

public A setToFromLabels(int index,
                         MetaDataFromLabel item)

addToFromLabels

public A addToFromLabels(MetaDataFromLabel... items)

addAllToFromLabels

public A addAllToFromLabels(Collection<MetaDataFromLabel> items)

removeFromFromLabels

public A removeFromFromLabels(MetaDataFromLabel... items)

removeAllFromFromLabels

public A removeAllFromFromLabels(Collection<MetaDataFromLabel> items)

removeMatchingFromFromLabels

public A removeMatchingFromFromLabels(Predicate<MetaDataFromLabelBuilder> predicate)

buildFromLabels

public List<MetaDataFromLabel> buildFromLabels()

buildFromLabel

public MetaDataFromLabel buildFromLabel(int index)

buildFirstFromLabel

public MetaDataFromLabel buildFirstFromLabel()

buildLastFromLabel

public MetaDataFromLabel buildLastFromLabel()

buildMatchingFromLabel

public MetaDataFromLabel buildMatchingFromLabel(Predicate<MetaDataFromLabelBuilder> predicate)

hasMatchingFromLabel

public boolean hasMatchingFromLabel(Predicate<MetaDataFromLabelBuilder> predicate)

withFromLabels

public A withFromLabels(List<MetaDataFromLabel> fromLabels)

withFromLabels

public A withFromLabels(MetaDataFromLabel... fromLabels)

hasFromLabels
```
public boolean hasFromLabels()
```

addNewFromLabel

public A addNewFromLabel(String key,
                         String label,
                         String object)

addNewFromLabel

public MetaDataFluent.FromLabelsNested<A> addNewFromLabel()

addNewFromLabelLike

public MetaDataFluent.FromLabelsNested<A> addNewFromLabelLike(MetaDataFromLabel item)

setNewFromLabelLike

public MetaDataFluent.FromLabelsNested<A> setNewFromLabelLike(int index,
                                                              MetaDataFromLabel item)

editFromLabel

public MetaDataFluent.FromLabelsNested<A> editFromLabel(int index)

editFirstFromLabel

public MetaDataFluent.FromLabelsNested<A> editFirstFromLabel()

editLastFromLabel

public MetaDataFluent.FromLabelsNested<A> editLastFromLabel()

editMatchingFromLabel

public MetaDataFluent.FromLabelsNested<A> editMatchingFromLabel(Predicate<MetaDataFromLabelBuilder> predicate)

addToGatewaysFromIPPool

public A addToGatewaysFromIPPool(int index,
                                 FromPool item)

setToGatewaysFromIPPool

public A setToGatewaysFromIPPool(int index,
                                 FromPool item)

addToGatewaysFromIPPool

public A addToGatewaysFromIPPool(FromPool... items)

addAllToGatewaysFromIPPool

public A addAllToGatewaysFromIPPool(Collection<FromPool> items)

removeFromGatewaysFromIPPool

public A removeFromGatewaysFromIPPool(FromPool... items)

removeAllFromGatewaysFromIPPool

public A removeAllFromGatewaysFromIPPool(Collection<FromPool> items)

removeMatchingFromGatewaysFromIPPool

public A removeMatchingFromGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)

buildGatewaysFromIPPool

public List<FromPool> buildGatewaysFromIPPool()

buildGatewaysFromIPPool

public FromPool buildGatewaysFromIPPool(int index)

buildFirstGatewaysFromIPPool

public FromPool buildFirstGatewaysFromIPPool()

buildLastGatewaysFromIPPool

public FromPool buildLastGatewaysFromIPPool()

buildMatchingGatewaysFromIPPool

public FromPool buildMatchingGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)

hasMatchingGatewaysFromIPPool

public boolean hasMatchingGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)

withGatewaysFromIPPool

public A withGatewaysFromIPPool(List<FromPool> gatewaysFromIPPool)

withGatewaysFromIPPool

public A withGatewaysFromIPPool(FromPool... gatewaysFromIPPool)

hasGatewaysFromIPPool

public boolean hasGatewaysFromIPPool()

addNewGatewaysFromIPPool

public A addNewGatewaysFromIPPool(String apiGroup,
                                  String key,
                                  String kind,
                                  String name)

addNewGatewaysFromIPPool

public MetaDataFluent.GatewaysFromIPPoolNested<A> addNewGatewaysFromIPPool()

addNewGatewaysFromIPPoolLike

public MetaDataFluent.GatewaysFromIPPoolNested<A> addNewGatewaysFromIPPoolLike(FromPool item)

setNewGatewaysFromIPPoolLike

public MetaDataFluent.GatewaysFromIPPoolNested<A> setNewGatewaysFromIPPoolLike(int index,
                                                                               FromPool item)

editGatewaysFromIPPool

public MetaDataFluent.GatewaysFromIPPoolNested<A> editGatewaysFromIPPool(int index)

editFirstGatewaysFromIPPool

public MetaDataFluent.GatewaysFromIPPoolNested<A> editFirstGatewaysFromIPPool()

editLastGatewaysFromIPPool

public MetaDataFluent.GatewaysFromIPPoolNested<A> editLastGatewaysFromIPPool()

editMatchingGatewaysFromIPPool

public MetaDataFluent.GatewaysFromIPPoolNested<A> editMatchingGatewaysFromIPPool(Predicate<FromPoolBuilder> predicate)

addToIndexes

public A addToIndexes(int index,
                      MetaDataIndex item)

setToIndexes

public A setToIndexes(int index,
                      MetaDataIndex item)

addToIndexes

public A addToIndexes(MetaDataIndex... items)

addAllToIndexes

public A addAllToIndexes(Collection<MetaDataIndex> items)

removeFromIndexes

public A removeFromIndexes(MetaDataIndex... items)

removeAllFromIndexes

public A removeAllFromIndexes(Collection<MetaDataIndex> items)

removeMatchingFromIndexes

public A removeMatchingFromIndexes(Predicate<MetaDataIndexBuilder> predicate)

buildIndexes

public List<MetaDataIndex> buildIndexes()

buildIndex

public MetaDataIndex buildIndex(int index)

buildFirstIndex

public MetaDataIndex buildFirstIndex()

buildLastIndex
```
public MetaDataIndex buildLastIndex()
```

buildMatchingIndex

public MetaDataIndex buildMatchingIndex(Predicate<MetaDataIndexBuilder> predicate)

hasMatchingIndex

public boolean hasMatchingIndex(Predicate<MetaDataIndexBuilder> predicate)

withIndexes

public A withIndexes(List<MetaDataIndex> indexes)

withIndexes

public A withIndexes(MetaDataIndex... indexes)

hasIndexes
```
public boolean hasIndexes()
```

addNewIndex

public A addNewIndex(String key,
                     Integer offset,
                     String prefix,
                     Integer step,
                     String suffix)

addNewIndex

public MetaDataFluent.IndexesNested<A> addNewIndex()

addNewIndexLike

public MetaDataFluent.IndexesNested<A> addNewIndexLike(MetaDataIndex item)

setNewIndexLike

public MetaDataFluent.IndexesNested<A> setNewIndexLike(int index,
                                                       MetaDataIndex item)

editIndex

public MetaDataFluent.IndexesNested<A> editIndex(int index)

editFirstIndex

public MetaDataFluent.IndexesNested<A> editFirstIndex()

editLastIndex

public MetaDataFluent.IndexesNested<A> editLastIndex()

editMatchingIndex

public MetaDataFluent.IndexesNested<A> editMatchingIndex(Predicate<MetaDataIndexBuilder> predicate)

addToIpAddressesFromIPPool

public A addToIpAddressesFromIPPool(int index,
                                    FromPool item)

setToIpAddressesFromIPPool

public A setToIpAddressesFromIPPool(int index,
                                    FromPool item)

addToIpAddressesFromIPPool

public A addToIpAddressesFromIPPool(FromPool... items)

addAllToIpAddressesFromIPPool

public A addAllToIpAddressesFromIPPool(Collection<FromPool> items)

removeFromIpAddressesFromIPPool

public A removeFromIpAddressesFromIPPool(FromPool... items)

removeAllFromIpAddressesFromIPPool

public A removeAllFromIpAddressesFromIPPool(Collection<FromPool> items)

removeMatchingFromIpAddressesFromIPPool

public A removeMatchingFromIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)

buildIpAddressesFromIPPool

public List<FromPool> buildIpAddressesFromIPPool()

buildIpAddressesFromIPPool

public FromPool buildIpAddressesFromIPPool(int index)

buildFirstIpAddressesFromIPPool

public FromPool buildFirstIpAddressesFromIPPool()

buildLastIpAddressesFromIPPool

public FromPool buildLastIpAddressesFromIPPool()

buildMatchingIpAddressesFromIPPool

public FromPool buildMatchingIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)

hasMatchingIpAddressesFromIPPool

public boolean hasMatchingIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)

withIpAddressesFromIPPool

public A withIpAddressesFromIPPool(List<FromPool> ipAddressesFromIPPool)

withIpAddressesFromIPPool

public A withIpAddressesFromIPPool(FromPool... ipAddressesFromIPPool)

hasIpAddressesFromIPPool

public boolean hasIpAddressesFromIPPool()

addNewIpAddressesFromIPPool

public A addNewIpAddressesFromIPPool(String apiGroup,
                                     String key,
                                     String kind,
                                     String name)

addNewIpAddressesFromIPPool

public MetaDataFluent.IpAddressesFromIPPoolNested<A> addNewIpAddressesFromIPPool()

addNewIpAddressesFromIPPoolLike

public MetaDataFluent.IpAddressesFromIPPoolNested<A> addNewIpAddressesFromIPPoolLike(FromPool item)

setNewIpAddressesFromIPPoolLike

public MetaDataFluent.IpAddressesFromIPPoolNested<A> setNewIpAddressesFromIPPoolLike(int index,
                                                                                     FromPool item)

editIpAddressesFromIPPool

public MetaDataFluent.IpAddressesFromIPPoolNested<A> editIpAddressesFromIPPool(int index)

editFirstIpAddressesFromIPPool

public MetaDataFluent.IpAddressesFromIPPoolNested<A> editFirstIpAddressesFromIPPool()

editLastIpAddressesFromIPPool

public MetaDataFluent.IpAddressesFromIPPoolNested<A> editLastIpAddressesFromIPPool()

editMatchingIpAddressesFromIPPool

public MetaDataFluent.IpAddressesFromIPPoolNested<A> editMatchingIpAddressesFromIPPool(Predicate<FromPoolBuilder> predicate)

addToNamespaces

public A addToNamespaces(int index,
                         MetaDataNamespace item)

setToNamespaces

public A setToNamespaces(int index,
                         MetaDataNamespace item)

addToNamespaces

public A addToNamespaces(MetaDataNamespace... items)

addAllToNamespaces

public A addAllToNamespaces(Collection<MetaDataNamespace> items)

removeFromNamespaces

public A removeFromNamespaces(MetaDataNamespace... items)

removeAllFromNamespaces

public A removeAllFromNamespaces(Collection<MetaDataNamespace> items)

removeMatchingFromNamespaces

public A removeMatchingFromNamespaces(Predicate<MetaDataNamespaceBuilder> predicate)

buildNamespaces

public List<MetaDataNamespace> buildNamespaces()

buildNamespace

public MetaDataNamespace buildNamespace(int index)

buildFirstNamespace

public MetaDataNamespace buildFirstNamespace()

buildLastNamespace

public MetaDataNamespace buildLastNamespace()

buildMatchingNamespace

public MetaDataNamespace buildMatchingNamespace(Predicate<MetaDataNamespaceBuilder> predicate)

hasMatchingNamespace

public boolean hasMatchingNamespace(Predicate<MetaDataNamespaceBuilder> predicate)

withNamespaces

public A withNamespaces(List<MetaDataNamespace> namespaces)

withNamespaces

public A withNamespaces(MetaDataNamespace... namespaces)

hasNamespaces
```
public boolean hasNamespaces()
```

addNewNamespace

public A addNewNamespace(String key)

addNewNamespace

public MetaDataFluent.NamespacesNested<A> addNewNamespace()

addNewNamespaceLike

public MetaDataFluent.NamespacesNested<A> addNewNamespaceLike(MetaDataNamespace item)

setNewNamespaceLike

public MetaDataFluent.NamespacesNested<A> setNewNamespaceLike(int index,
                                                              MetaDataNamespace item)

editNamespace

public MetaDataFluent.NamespacesNested<A> editNamespace(int index)

editFirstNamespace

public MetaDataFluent.NamespacesNested<A> editFirstNamespace()

editLastNamespace

public MetaDataFluent.NamespacesNested<A> editLastNamespace()

editMatchingNamespace

public MetaDataFluent.NamespacesNested<A> editMatchingNamespace(Predicate<MetaDataNamespaceBuilder> predicate)

addToObjectNames

public A addToObjectNames(int index,
                          MetaDataObjectName item)

setToObjectNames

public A setToObjectNames(int index,
                          MetaDataObjectName item)

addToObjectNames

public A addToObjectNames(MetaDataObjectName... items)

addAllToObjectNames

public A addAllToObjectNames(Collection<MetaDataObjectName> items)

removeFromObjectNames

public A removeFromObjectNames(MetaDataObjectName... items)

removeAllFromObjectNames

public A removeAllFromObjectNames(Collection<MetaDataObjectName> items)

removeMatchingFromObjectNames

public A removeMatchingFromObjectNames(Predicate<MetaDataObjectNameBuilder> predicate)

buildObjectNames

public List<MetaDataObjectName> buildObjectNames()

buildObjectName

public MetaDataObjectName buildObjectName(int index)

buildFirstObjectName

public MetaDataObjectName buildFirstObjectName()

buildLastObjectName

public MetaDataObjectName buildLastObjectName()

buildMatchingObjectName

public MetaDataObjectName buildMatchingObjectName(Predicate<MetaDataObjectNameBuilder> predicate)

hasMatchingObjectName

public boolean hasMatchingObjectName(Predicate<MetaDataObjectNameBuilder> predicate)

withObjectNames

public A withObjectNames(List<MetaDataObjectName> objectNames)

withObjectNames

public A withObjectNames(MetaDataObjectName... objectNames)

hasObjectNames
```
public boolean hasObjectNames()
```

addNewObjectName

public A addNewObjectName(String key,
                          String object)

addNewObjectName

public MetaDataFluent.ObjectNamesNested<A> addNewObjectName()

addNewObjectNameLike

public MetaDataFluent.ObjectNamesNested<A> addNewObjectNameLike(MetaDataObjectName item)

setNewObjectNameLike

public MetaDataFluent.ObjectNamesNested<A> setNewObjectNameLike(int index,
                                                                MetaDataObjectName item)

editObjectName

public MetaDataFluent.ObjectNamesNested<A> editObjectName(int index)

editFirstObjectName

public MetaDataFluent.ObjectNamesNested<A> editFirstObjectName()

editLastObjectName

public MetaDataFluent.ObjectNamesNested<A> editLastObjectName()

editMatchingObjectName

public MetaDataFluent.ObjectNamesNested<A> editMatchingObjectName(Predicate<MetaDataObjectNameBuilder> predicate)

addToPrefixesFromIPPool

public A addToPrefixesFromIPPool(int index,
                                 FromPool item)

setToPrefixesFromIPPool

public A setToPrefixesFromIPPool(int index,
                                 FromPool item)

addToPrefixesFromIPPool

public A addToPrefixesFromIPPool(FromPool... items)

addAllToPrefixesFromIPPool

public A addAllToPrefixesFromIPPool(Collection<FromPool> items)

removeFromPrefixesFromIPPool

public A removeFromPrefixesFromIPPool(FromPool... items)

removeAllFromPrefixesFromIPPool

public A removeAllFromPrefixesFromIPPool(Collection<FromPool> items)

removeMatchingFromPrefixesFromIPPool

public A removeMatchingFromPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)

buildPrefixesFromIPPool

public List<FromPool> buildPrefixesFromIPPool()

buildPrefixesFromIPPool

public FromPool buildPrefixesFromIPPool(int index)

buildFirstPrefixesFromIPPool

public FromPool buildFirstPrefixesFromIPPool()

buildLastPrefixesFromIPPool

public FromPool buildLastPrefixesFromIPPool()

buildMatchingPrefixesFromIPPool

public FromPool buildMatchingPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)

hasMatchingPrefixesFromIPPool

public boolean hasMatchingPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)

withPrefixesFromIPPool

public A withPrefixesFromIPPool(List<FromPool> prefixesFromIPPool)

withPrefixesFromIPPool

public A withPrefixesFromIPPool(FromPool... prefixesFromIPPool)

hasPrefixesFromIPPool

public boolean hasPrefixesFromIPPool()

addNewPrefixesFromIPPool

public A addNewPrefixesFromIPPool(String apiGroup,
                                  String key,
                                  String kind,
                                  String name)

addNewPrefixesFromIPPool

public MetaDataFluent.PrefixesFromIPPoolNested<A> addNewPrefixesFromIPPool()

addNewPrefixesFromIPPoolLike

public MetaDataFluent.PrefixesFromIPPoolNested<A> addNewPrefixesFromIPPoolLike(FromPool item)

setNewPrefixesFromIPPoolLike

public MetaDataFluent.PrefixesFromIPPoolNested<A> setNewPrefixesFromIPPoolLike(int index,
                                                                               FromPool item)

editPrefixesFromIPPool

public MetaDataFluent.PrefixesFromIPPoolNested<A> editPrefixesFromIPPool(int index)

editFirstPrefixesFromIPPool

public MetaDataFluent.PrefixesFromIPPoolNested<A> editFirstPrefixesFromIPPool()

editLastPrefixesFromIPPool

public MetaDataFluent.PrefixesFromIPPoolNested<A> editLastPrefixesFromIPPool()

editMatchingPrefixesFromIPPool

public MetaDataFluent.PrefixesFromIPPoolNested<A> editMatchingPrefixesFromIPPool(Predicate<FromPoolBuilder> predicate)

addToStrings

public A addToStrings(int index,
                      MetaDataString item)

setToStrings

public A setToStrings(int index,
                      MetaDataString item)

addToStrings

public A addToStrings(MetaDataString... items)

addAllToStrings

public A addAllToStrings(Collection<MetaDataString> items)

removeFromStrings

public A removeFromStrings(MetaDataString... items)

removeAllFromStrings

public A removeAllFromStrings(Collection<MetaDataString> items)

removeMatchingFromStrings

public A removeMatchingFromStrings(Predicate<MetaDataStringBuilder> predicate)

buildStrings

public List<MetaDataString> buildStrings()

buildString

public MetaDataString buildString(int index)

buildFirstString

public MetaDataString buildFirstString()

buildLastString

public MetaDataString buildLastString()

buildMatchingString

public MetaDataString buildMatchingString(Predicate<MetaDataStringBuilder> predicate)

hasMatchingString

public boolean hasMatchingString(Predicate<MetaDataStringBuilder> predicate)

withStrings

public A withStrings(List<MetaDataString> strings)

withStrings

public A withStrings(MetaDataString... strings)

hasStrings
```
public boolean hasStrings()
```

addNewString

public A addNewString(String key,
                      String value)

addNewString

public MetaDataFluent.StringsNested<A> addNewString()

addNewStringLike

public MetaDataFluent.StringsNested<A> addNewStringLike(MetaDataString item)

setNewStringLike

public MetaDataFluent.StringsNested<A> setNewStringLike(int index,
                                                        MetaDataString item)

editString

public MetaDataFluent.StringsNested<A> editString(int index)

editFirstString

public MetaDataFluent.StringsNested<A> editFirstString()

editLastString

public MetaDataFluent.StringsNested<A> editLastString()

editMatchingString

public MetaDataFluent.StringsNested<A> editMatchingString(Predicate<MetaDataStringBuilder> predicate)

addToAdditionalProperties

public A addToAdditionalProperties(String key,
                                   Object value)

addToAdditionalProperties

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

removeFromAdditionalProperties

public A removeFromAdditionalProperties(String key)

removeFromAdditionalProperties

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

getAdditionalProperties

public Map<String,Object> getAdditionalProperties()

withAdditionalProperties

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

hasAdditionalProperties

public boolean hasAdditionalProperties()

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

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

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

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

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

toString in class Object

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

Constructor Detail

MetaDataFluent

MetaDataFluent

Method Detail

copyInstance

addToDnsServersFromIPPool

setToDnsServersFromIPPool

addToDnsServersFromIPPool

addAllToDnsServersFromIPPool

removeFromDnsServersFromIPPool

removeAllFromDnsServersFromIPPool

removeMatchingFromDnsServersFromIPPool

buildDnsServersFromIPPool

buildDnsServersFromIPPool

buildFirstDnsServersFromIPPool

buildLastDnsServersFromIPPool

buildMatchingDnsServersFromIPPool

hasMatchingDnsServersFromIPPool

withDnsServersFromIPPool

withDnsServersFromIPPool

hasDnsServersFromIPPool

addNewDnsServersFromIPPool

addNewDnsServersFromIPPool

addNewDnsServersFromIPPoolLike

setNewDnsServersFromIPPoolLike

editDnsServersFromIPPool

editFirstDnsServersFromIPPool

editLastDnsServersFromIPPool

editMatchingDnsServersFromIPPool

addToFromAnnotations

setToFromAnnotations

addToFromAnnotations

addAllToFromAnnotations

removeFromFromAnnotations

removeAllFromFromAnnotations

removeMatchingFromFromAnnotations

buildFromAnnotations

buildFromAnnotation

buildFirstFromAnnotation

buildLastFromAnnotation

buildMatchingFromAnnotation

hasMatchingFromAnnotation

withFromAnnotations

withFromAnnotations

hasFromAnnotations

addNewFromAnnotation

addNewFromAnnotation

addNewFromAnnotationLike

setNewFromAnnotationLike

editFromAnnotation

editFirstFromAnnotation

editLastFromAnnotation

editMatchingFromAnnotation

addToFromHostInterfaces

setToFromHostInterfaces

addToFromHostInterfaces

addAllToFromHostInterfaces

removeFromFromHostInterfaces

removeAllFromFromHostInterfaces

removeMatchingFromFromHostInterfaces

buildFromHostInterfaces

buildFromHostInterface

buildFirstFromHostInterface

buildLastFromHostInterface

buildMatchingFromHostInterface

hasMatchingFromHostInterface

withFromHostInterfaces

withFromHostInterfaces

hasFromHostInterfaces

addNewFromHostInterface

addNewFromHostInterface

addNewFromHostInterfaceLike