java.lang.Object
- io.sundr.builder.BaseFluent<A>
- - io.sundr.model.AttributeSupportFluent<A>
  - - io.sundr.model.ModifierSupportFluent<A>
    - - io.sundr.model.TypeDefFluent<A>

Direct Known Subclasses:

SourceFluent.TypesNested, TypeDefBuilder, TypeDefFluent.InnerTypesNested
```
public class TypeDefFluent<A extends TypeDefFluent<A>>
extends ModifierSupportFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`TypeDefFluent.AnnotationsNested<N>`
`class`	`TypeDefFluent.ConstructorsNested<N>`
`class`	`TypeDefFluent.ExtendsListNested<N>`
`class`	`TypeDefFluent.ImplementsListNested<N>`
`class`	`TypeDefFluent.InnerTypesNested<N>`
`class`	`TypeDefFluent.MethodsNested<N>`
`class`	`TypeDefFluent.ParametersNested<N>`
`class`	`TypeDefFluent.PropertiesNested<N>`

Nested classes/interfaces inherited from class io.sundr.model.ModifierSupportFluent
ModifierSupportFluent.ModifiersNested<N>

Field Summary
- Fields inherited from class io.sundr.builder.BaseFluent
  _visitables

Constructor Summary

Constructors
Constructor Description

TypeDefFluent()

TypeDefFluent(TypeDef instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToAnnotations(Collection<AnnotationRef> items)`
`A`	`addAllToComments(Collection<String> items)`
`A`	`addAllToConstructors(Collection<Method> items)`
`A`	`addAllToExtendsList(Collection<ClassRef> items)`
`A`	`addAllToImplementsList(Collection<ClassRef> items)`
`A`	`addAllToInnerTypes(Collection<TypeDef> items)`
`A`	`addAllToMethods(Collection<Method> items)`
`A`	`addAllToParameters(Collection<TypeParamDef> items)`
`A`	`addAllToProperties(Collection<Property> items)`
`TypeDefFluent.AnnotationsNested<A>`	`addNewAnnotation()`
`TypeDefFluent.AnnotationsNested<A>`	`addNewAnnotationLike(AnnotationRef item)`
`TypeDefFluent.ConstructorsNested<A>`	`addNewConstructor()`
`TypeDefFluent.ConstructorsNested<A>`	`addNewConstructorLike(Method item)`
`TypeDefFluent.ExtendsListNested<A>`	`addNewExtendsList()`
`TypeDefFluent.ExtendsListNested<A>`	`addNewExtendsListLike(ClassRef item)`
`TypeDefFluent.ImplementsListNested<A>`	`addNewImplementsList()`
`TypeDefFluent.ImplementsListNested<A>`	`addNewImplementsListLike(ClassRef item)`
`TypeDefFluent.InnerTypesNested<A>`	`addNewInnerType()`
`A`	`addNewInnerType(String fullyQualifiedName)`
`TypeDefFluent.InnerTypesNested<A>`	`addNewInnerTypeLike(TypeDef item)`
`TypeDefFluent.MethodsNested<A>`	`addNewMethod()`
`TypeDefFluent.MethodsNested<A>`	`addNewMethodLike(Method item)`
`TypeDefFluent.ParametersNested<A>`	`addNewParameter()`
`TypeDefFluent.ParametersNested<A>`	`addNewParameterLike(TypeParamDef item)`
`TypeDefFluent.PropertiesNested<A>`	`addNewProperty()`
`TypeDefFluent.PropertiesNested<A>`	`addNewPropertyLike(Property item)`
`A`	`addToAnnotations(int index, AnnotationRef item)`
`A`	`addToAnnotations(AnnotationRef... items)`
`A`	`addToComments(int index, String item)`
`A`	`addToComments(String... items)`
`A`	`addToConstructors(int index, Method item)`
`A`	`addToConstructors(Method... items)`
`A`	`addToExtendsList(int index, ClassRef item)`
`A`	`addToExtendsList(ClassRef... items)`
`A`	`addToImplementsList(int index, ClassRef item)`
`A`	`addToImplementsList(ClassRef... items)`
`A`	`addToInnerTypes(int index, TypeDef item)`
`A`	`addToInnerTypes(TypeDef... items)`
`A`	`addToMethods(int index, Method item)`
`A`	`addToMethods(Method... items)`
`A`	`addToParameters(int index, TypeParamDef item)`
`A`	`addToParameters(TypeParamDef... items)`
`A`	`addToProperties(int index, Property item)`
`A`	`addToProperties(Property... items)`
`AnnotationRef`	`buildAnnotation(int index)`
`List<AnnotationRef>`	`buildAnnotations()`
`Method`	`buildConstructor(int index)`
`List<Method>`	`buildConstructors()`
`List<ClassRef>`	`buildExtendsList()`
`ClassRef`	`buildExtendsList(int index)`
`AnnotationRef`	`buildFirstAnnotation()`
`Method`	`buildFirstConstructor()`
`ClassRef`	`buildFirstExtendsList()`
`ClassRef`	`buildFirstImplementsList()`
`TypeDef`	`buildFirstInnerType()`
`Method`	`buildFirstMethod()`
`TypeParamDef`	`buildFirstParameter()`
`Property`	`buildFirstProperty()`
`List<ClassRef>`	`buildImplementsList()`
`ClassRef`	`buildImplementsList(int index)`
`TypeDef`	`buildInnerType(int index)`
`List<TypeDef>`	`buildInnerTypes()`
`AnnotationRef`	`buildLastAnnotation()`
`Method`	`buildLastConstructor()`
`ClassRef`	`buildLastExtendsList()`
`ClassRef`	`buildLastImplementsList()`
`TypeDef`	`buildLastInnerType()`
`Method`	`buildLastMethod()`
`TypeParamDef`	`buildLastParameter()`
`Property`	`buildLastProperty()`
`AnnotationRef`	`buildMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)`
`Method`	`buildMatchingConstructor(Predicate<MethodBuilder> predicate)`
`ClassRef`	`buildMatchingExtendsList(Predicate<ClassRefBuilder> predicate)`
`ClassRef`	`buildMatchingImplementsList(Predicate<ClassRefBuilder> predicate)`
`TypeDef`	`buildMatchingInnerType(Predicate<TypeDefBuilder> predicate)`
`Method`	`buildMatchingMethod(Predicate<MethodBuilder> predicate)`
`TypeParamDef`	`buildMatchingParameter(Predicate<TypeParamDefBuilder> predicate)`
`Property`	`buildMatchingProperty(Predicate<PropertyBuilder> predicate)`
`Method`	`buildMethod(int index)`
`List<Method>`	`buildMethods()`
`TypeParamDef`	`buildParameter(int index)`
`List<TypeParamDef>`	`buildParameters()`
`List<Property>`	`buildProperties()`
`Property`	`buildProperty(int index)`
`protected void`	`copyInstance(TypeDef instance)`
`TypeDefFluent.AnnotationsNested<A>`	`editAnnotation(int index)`
`TypeDefFluent.ConstructorsNested<A>`	`editConstructor(int index)`
`TypeDefFluent.ExtendsListNested<A>`	`editExtendsList(int index)`
`TypeDefFluent.AnnotationsNested<A>`	`editFirstAnnotation()`
`TypeDefFluent.ConstructorsNested<A>`	`editFirstConstructor()`
`TypeDefFluent.ExtendsListNested<A>`	`editFirstExtendsList()`
`TypeDefFluent.ImplementsListNested<A>`	`editFirstImplementsList()`
`TypeDefFluent.InnerTypesNested<A>`	`editFirstInnerType()`
`TypeDefFluent.MethodsNested<A>`	`editFirstMethod()`
`TypeDefFluent.ParametersNested<A>`	`editFirstParameter()`
`TypeDefFluent.PropertiesNested<A>`	`editFirstProperty()`
`TypeDefFluent.ImplementsListNested<A>`	`editImplementsList(int index)`
`TypeDefFluent.InnerTypesNested<A>`	`editInnerType(int index)`
`TypeDefFluent.AnnotationsNested<A>`	`editLastAnnotation()`
`TypeDefFluent.ConstructorsNested<A>`	`editLastConstructor()`
`TypeDefFluent.ExtendsListNested<A>`	`editLastExtendsList()`
`TypeDefFluent.ImplementsListNested<A>`	`editLastImplementsList()`
`TypeDefFluent.InnerTypesNested<A>`	`editLastInnerType()`
`TypeDefFluent.MethodsNested<A>`	`editLastMethod()`
`TypeDefFluent.ParametersNested<A>`	`editLastParameter()`
`TypeDefFluent.PropertiesNested<A>`	`editLastProperty()`
`TypeDefFluent.AnnotationsNested<A>`	`editMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)`
`TypeDefFluent.ConstructorsNested<A>`	`editMatchingConstructor(Predicate<MethodBuilder> predicate)`
`TypeDefFluent.ExtendsListNested<A>`	`editMatchingExtendsList(Predicate<ClassRefBuilder> predicate)`
`TypeDefFluent.ImplementsListNested<A>`	`editMatchingImplementsList(Predicate<ClassRefBuilder> predicate)`
`TypeDefFluent.InnerTypesNested<A>`	`editMatchingInnerType(Predicate<TypeDefBuilder> predicate)`
`TypeDefFluent.MethodsNested<A>`	`editMatchingMethod(Predicate<MethodBuilder> predicate)`
`TypeDefFluent.ParametersNested<A>`	`editMatchingParameter(Predicate<TypeParamDefBuilder> predicate)`
`TypeDefFluent.PropertiesNested<A>`	`editMatchingProperty(Predicate<PropertyBuilder> predicate)`
`TypeDefFluent.MethodsNested<A>`	`editMethod(int index)`
`TypeDefFluent.ParametersNested<A>`	`editParameter(int index)`
`TypeDefFluent.PropertiesNested<A>`	`editProperty(int index)`
`boolean`	`equals(Object o)`
`String`	`getComment(int index)`
`List<String>`	`getComments()`
`String`	`getFirstComment()`
`Kind`	`getKind()`
`String`	`getLastComment()`
`String`	`getMatchingComment(Predicate<String> predicate)`
`String`	`getName()`
`String`	`getOuterTypeName()`
`String`	`getPackageName()`
`boolean`	`hasAnnotations()`
`boolean`	`hasComments()`
`boolean`	`hasConstructors()`
`boolean`	`hasExtendsList()`
`int`	`hashCode()`
`boolean`	`hasImplementsList()`
`boolean`	`hasInnerTypes()`
`boolean`	`hasKind()`
`boolean`	`hasMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)`
`boolean`	`hasMatchingComment(Predicate<String> predicate)`
`boolean`	`hasMatchingConstructor(Predicate<MethodBuilder> predicate)`
`boolean`	`hasMatchingExtendsList(Predicate<ClassRefBuilder> predicate)`
`boolean`	`hasMatchingImplementsList(Predicate<ClassRefBuilder> predicate)`
`boolean`	`hasMatchingInnerType(Predicate<TypeDefBuilder> predicate)`
`boolean`	`hasMatchingMethod(Predicate<MethodBuilder> predicate)`
`boolean`	`hasMatchingParameter(Predicate<TypeParamDefBuilder> predicate)`
`boolean`	`hasMatchingProperty(Predicate<PropertyBuilder> predicate)`
`boolean`	`hasMethods()`
`boolean`	`hasName()`
`boolean`	`hasOuterTypeName()`
`boolean`	`hasPackageName()`
`boolean`	`hasParameters()`
`boolean`	`hasProperties()`
`A`	`removeAllFromAnnotations(Collection<AnnotationRef> items)`
`A`	`removeAllFromComments(Collection<String> items)`
`A`	`removeAllFromConstructors(Collection<Method> items)`
`A`	`removeAllFromExtendsList(Collection<ClassRef> items)`
`A`	`removeAllFromImplementsList(Collection<ClassRef> items)`
`A`	`removeAllFromInnerTypes(Collection<TypeDef> items)`
`A`	`removeAllFromMethods(Collection<Method> items)`
`A`	`removeAllFromParameters(Collection<TypeParamDef> items)`
`A`	`removeAllFromProperties(Collection<Property> items)`
`A`	`removeFromAnnotations(AnnotationRef... items)`
`A`	`removeFromComments(String... items)`
`A`	`removeFromConstructors(Method... items)`
`A`	`removeFromExtendsList(ClassRef... items)`
`A`	`removeFromImplementsList(ClassRef... items)`
`A`	`removeFromInnerTypes(TypeDef... items)`
`A`	`removeFromMethods(Method... items)`
`A`	`removeFromParameters(TypeParamDef... items)`
`A`	`removeFromProperties(Property... items)`
`A`	`removeMatchingFromAnnotations(Predicate<AnnotationRefBuilder> predicate)`
`A`	`removeMatchingFromConstructors(Predicate<MethodBuilder> predicate)`
`A`	`removeMatchingFromExtendsList(Predicate<ClassRefBuilder> predicate)`
`A`	`removeMatchingFromImplementsList(Predicate<ClassRefBuilder> predicate)`
`A`	`removeMatchingFromInnerTypes(Predicate<TypeDefBuilder> predicate)`
`A`	`removeMatchingFromMethods(Predicate<MethodBuilder> predicate)`
`A`	`removeMatchingFromParameters(Predicate<TypeParamDefBuilder> predicate)`
`A`	`removeMatchingFromProperties(Predicate<PropertyBuilder> predicate)`
`TypeDefFluent.AnnotationsNested<A>`	`setNewAnnotationLike(int index, AnnotationRef item)`
`TypeDefFluent.ConstructorsNested<A>`	`setNewConstructorLike(int index, Method item)`
`TypeDefFluent.ExtendsListNested<A>`	`setNewExtendsListLike(int index, ClassRef item)`
`TypeDefFluent.ImplementsListNested<A>`	`setNewImplementsListLike(int index, ClassRef item)`
`TypeDefFluent.InnerTypesNested<A>`	`setNewInnerTypeLike(int index, TypeDef item)`
`TypeDefFluent.MethodsNested<A>`	`setNewMethodLike(int index, Method item)`
`TypeDefFluent.ParametersNested<A>`	`setNewParameterLike(int index, TypeParamDef item)`
`TypeDefFluent.PropertiesNested<A>`	`setNewPropertyLike(int index, Property item)`
`A`	`setToAnnotations(int index, AnnotationRef item)`
`A`	`setToComments(int index, String item)`
`A`	`setToConstructors(int index, Method item)`
`A`	`setToExtendsList(int index, ClassRef item)`
`A`	`setToImplementsList(int index, ClassRef item)`
`A`	`setToInnerTypes(int index, TypeDef item)`
`A`	`setToMethods(int index, Method item)`
`A`	`setToParameters(int index, TypeParamDef item)`
`A`	`setToProperties(int index, Property item)`
`String`	`toString()`
`A`	`withAnnotations(AnnotationRef... annotations)`
`A`	`withAnnotations(List<AnnotationRef> annotations)`
`A`	`withComments(String... comments)`
`A`	`withComments(List<String> comments)`
`A`	`withConstructors(Method... constructors)`
`A`	`withConstructors(List<Method> constructors)`
`A`	`withExtendsList(ClassRef... extendsList)`
`A`	`withExtendsList(List<ClassRef> extendsList)`
`A`	`withImplementsList(ClassRef... implementsList)`
`A`	`withImplementsList(List<ClassRef> implementsList)`
`A`	`withInnerTypes(TypeDef... innerTypes)`
`A`	`withInnerTypes(List<TypeDef> innerTypes)`
`A`	`withKind(Kind kind)`
`A`	`withMethods(Method... methods)`
`A`	`withMethods(List<Method> methods)`
`A`	`withName(String name)`
`A`	`withOuterTypeName(String outerTypeName)`
`A`	`withPackageName(String packageName)`
`A`	`withParameters(TypeParamDef... parameters)`
`A`	`withParameters(List<TypeParamDef> parameters)`
`A`	`withProperties(Property... properties)`
`A`	`withProperties(List<Property> properties)`

Methods inherited from class io.sundr.model.ModifierSupportFluent
buildModifiers, copyInstance, editModifiers, editOrNewModifiers, editOrNewModifiersLike, hasModifiers, withModifiers, withNewModifiers, withNewModifiersLike

Methods inherited from class io.sundr.model.AttributeSupportFluent
addToAttributes, addToAttributes, copyInstance, getAttributes, hasAttributes, removeFromAttributes, removeFromAttributes, withAttributes

Methods inherited from class io.sundr.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

TypeDefFluent
```
public TypeDefFluent()
```

TypeDefFluent

public TypeDefFluent(TypeDef instance)

Method Detail

copyInstance

protected void copyInstance(TypeDef instance)

getKind
```
public Kind getKind()
```

withKind
```
public A withKind(Kind kind)
```

hasKind
```
public boolean hasKind()
```

getPackageName
```
public String getPackageName()
```

withPackageName

public A withPackageName(String packageName)

hasPackageName
```
public boolean hasPackageName()
```

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

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

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

addToComments

public A addToComments(int index,
                       String item)

setToComments

public A setToComments(int index,
                       String item)

addToComments

public A addToComments(String... items)

addAllToComments

public A addAllToComments(Collection<String> items)

removeFromComments

public A removeFromComments(String... items)

removeAllFromComments

public A removeAllFromComments(Collection<String> items)

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

getComment

public String getComment(int index)

getFirstComment
```
public String getFirstComment()
```

getLastComment
```
public String getLastComment()
```

getMatchingComment

public String getMatchingComment(Predicate<String> predicate)

hasMatchingComment

public boolean hasMatchingComment(Predicate<String> predicate)

withComments

public A withComments(List<String> comments)

withComments

public A withComments(String... comments)

hasComments
```
public boolean hasComments()
```

addToAnnotations

public A addToAnnotations(int index,
                          AnnotationRef item)

setToAnnotations

public A setToAnnotations(int index,
                          AnnotationRef item)

addToAnnotations

public A addToAnnotations(AnnotationRef... items)

addAllToAnnotations

public A addAllToAnnotations(Collection<AnnotationRef> items)

removeFromAnnotations

public A removeFromAnnotations(AnnotationRef... items)

removeAllFromAnnotations

public A removeAllFromAnnotations(Collection<AnnotationRef> items)

removeMatchingFromAnnotations

public A removeMatchingFromAnnotations(Predicate<AnnotationRefBuilder> predicate)

buildAnnotations

public List<AnnotationRef> buildAnnotations()

buildAnnotation

public AnnotationRef buildAnnotation(int index)

buildFirstAnnotation

public AnnotationRef buildFirstAnnotation()

buildLastAnnotation

public AnnotationRef buildLastAnnotation()

buildMatchingAnnotation

public AnnotationRef buildMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)

hasMatchingAnnotation

public boolean hasMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)

withAnnotations

public A withAnnotations(List<AnnotationRef> annotations)

withAnnotations

public A withAnnotations(AnnotationRef... annotations)

hasAnnotations
```
public boolean hasAnnotations()
```

addNewAnnotation

public TypeDefFluent.AnnotationsNested<A> addNewAnnotation()

addNewAnnotationLike

public TypeDefFluent.AnnotationsNested<A> addNewAnnotationLike(AnnotationRef item)

setNewAnnotationLike

public TypeDefFluent.AnnotationsNested<A> setNewAnnotationLike(int index,
                                                               AnnotationRef item)

editAnnotation

public TypeDefFluent.AnnotationsNested<A> editAnnotation(int index)

editFirstAnnotation

public TypeDefFluent.AnnotationsNested<A> editFirstAnnotation()

editLastAnnotation

public TypeDefFluent.AnnotationsNested<A> editLastAnnotation()

editMatchingAnnotation

public TypeDefFluent.AnnotationsNested<A> editMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)

addToExtendsList

public A addToExtendsList(int index,
                          ClassRef item)

setToExtendsList

public A setToExtendsList(int index,
                          ClassRef item)

addToExtendsList

public A addToExtendsList(ClassRef... items)

addAllToExtendsList

public A addAllToExtendsList(Collection<ClassRef> items)

removeFromExtendsList

public A removeFromExtendsList(ClassRef... items)

removeAllFromExtendsList

public A removeAllFromExtendsList(Collection<ClassRef> items)

removeMatchingFromExtendsList

public A removeMatchingFromExtendsList(Predicate<ClassRefBuilder> predicate)

buildExtendsList

public List<ClassRef> buildExtendsList()

buildExtendsList

public ClassRef buildExtendsList(int index)

buildFirstExtendsList

public ClassRef buildFirstExtendsList()

buildLastExtendsList

public ClassRef buildLastExtendsList()

buildMatchingExtendsList

public ClassRef buildMatchingExtendsList(Predicate<ClassRefBuilder> predicate)

hasMatchingExtendsList

public boolean hasMatchingExtendsList(Predicate<ClassRefBuilder> predicate)

withExtendsList

public A withExtendsList(List<ClassRef> extendsList)

withExtendsList

public A withExtendsList(ClassRef... extendsList)

hasExtendsList
```
public boolean hasExtendsList()
```

addNewExtendsList

public TypeDefFluent.ExtendsListNested<A> addNewExtendsList()

addNewExtendsListLike

public TypeDefFluent.ExtendsListNested<A> addNewExtendsListLike(ClassRef item)

setNewExtendsListLike

public TypeDefFluent.ExtendsListNested<A> setNewExtendsListLike(int index,
                                                                ClassRef item)

editExtendsList

public TypeDefFluent.ExtendsListNested<A> editExtendsList(int index)

editFirstExtendsList

public TypeDefFluent.ExtendsListNested<A> editFirstExtendsList()

editLastExtendsList

public TypeDefFluent.ExtendsListNested<A> editLastExtendsList()

editMatchingExtendsList

public TypeDefFluent.ExtendsListNested<A> editMatchingExtendsList(Predicate<ClassRefBuilder> predicate)

addToImplementsList

public A addToImplementsList(int index,
                             ClassRef item)

setToImplementsList

public A setToImplementsList(int index,
                             ClassRef item)

addToImplementsList

public A addToImplementsList(ClassRef... items)

addAllToImplementsList

public A addAllToImplementsList(Collection<ClassRef> items)

removeFromImplementsList

public A removeFromImplementsList(ClassRef... items)

removeAllFromImplementsList

public A removeAllFromImplementsList(Collection<ClassRef> items)

removeMatchingFromImplementsList

public A removeMatchingFromImplementsList(Predicate<ClassRefBuilder> predicate)

buildImplementsList

public List<ClassRef> buildImplementsList()

buildImplementsList

public ClassRef buildImplementsList(int index)

buildFirstImplementsList

public ClassRef buildFirstImplementsList()

buildLastImplementsList

public ClassRef buildLastImplementsList()

buildMatchingImplementsList

public ClassRef buildMatchingImplementsList(Predicate<ClassRefBuilder> predicate)

hasMatchingImplementsList

public boolean hasMatchingImplementsList(Predicate<ClassRefBuilder> predicate)

withImplementsList

public A withImplementsList(List<ClassRef> implementsList)

withImplementsList

public A withImplementsList(ClassRef... implementsList)

hasImplementsList
```
public boolean hasImplementsList()
```

addNewImplementsList

public TypeDefFluent.ImplementsListNested<A> addNewImplementsList()

addNewImplementsListLike

public TypeDefFluent.ImplementsListNested<A> addNewImplementsListLike(ClassRef item)

setNewImplementsListLike

public TypeDefFluent.ImplementsListNested<A> setNewImplementsListLike(int index,
                                                                      ClassRef item)

editImplementsList

public TypeDefFluent.ImplementsListNested<A> editImplementsList(int index)

editFirstImplementsList

public TypeDefFluent.ImplementsListNested<A> editFirstImplementsList()

editLastImplementsList

public TypeDefFluent.ImplementsListNested<A> editLastImplementsList()

editMatchingImplementsList

public TypeDefFluent.ImplementsListNested<A> editMatchingImplementsList(Predicate<ClassRefBuilder> predicate)

addToParameters

public A addToParameters(int index,
                         TypeParamDef item)

setToParameters

public A setToParameters(int index,
                         TypeParamDef item)

addToParameters

public A addToParameters(TypeParamDef... items)

addAllToParameters

public A addAllToParameters(Collection<TypeParamDef> items)

removeFromParameters

public A removeFromParameters(TypeParamDef... items)

removeAllFromParameters

public A removeAllFromParameters(Collection<TypeParamDef> items)

removeMatchingFromParameters

public A removeMatchingFromParameters(Predicate<TypeParamDefBuilder> predicate)

buildParameters

public List<TypeParamDef> buildParameters()

buildParameter

public TypeParamDef buildParameter(int index)

buildFirstParameter

public TypeParamDef buildFirstParameter()

buildLastParameter

public TypeParamDef buildLastParameter()

buildMatchingParameter

public TypeParamDef buildMatchingParameter(Predicate<TypeParamDefBuilder> predicate)

hasMatchingParameter

public boolean hasMatchingParameter(Predicate<TypeParamDefBuilder> predicate)

withParameters

public A withParameters(List<TypeParamDef> parameters)

withParameters

public A withParameters(TypeParamDef... parameters)

hasParameters
```
public boolean hasParameters()
```

addNewParameter

public TypeDefFluent.ParametersNested<A> addNewParameter()

addNewParameterLike

public TypeDefFluent.ParametersNested<A> addNewParameterLike(TypeParamDef item)

setNewParameterLike

public TypeDefFluent.ParametersNested<A> setNewParameterLike(int index,
                                                             TypeParamDef item)

editParameter

public TypeDefFluent.ParametersNested<A> editParameter(int index)

editFirstParameter

public TypeDefFluent.ParametersNested<A> editFirstParameter()

editLastParameter

public TypeDefFluent.ParametersNested<A> editLastParameter()

editMatchingParameter

public TypeDefFluent.ParametersNested<A> editMatchingParameter(Predicate<TypeParamDefBuilder> predicate)

addToProperties

public A addToProperties(int index,
                         Property item)

setToProperties

public A setToProperties(int index,
                         Property item)

addToProperties

public A addToProperties(Property... items)

addAllToProperties

public A addAllToProperties(Collection<Property> items)

removeFromProperties

public A removeFromProperties(Property... items)

removeAllFromProperties

public A removeAllFromProperties(Collection<Property> items)

removeMatchingFromProperties

public A removeMatchingFromProperties(Predicate<PropertyBuilder> predicate)

buildProperties

public List<Property> buildProperties()

buildProperty

public Property buildProperty(int index)

buildFirstProperty
```
public Property buildFirstProperty()
```

buildLastProperty
```
public Property buildLastProperty()
```

buildMatchingProperty

public Property buildMatchingProperty(Predicate<PropertyBuilder> predicate)

hasMatchingProperty

public boolean hasMatchingProperty(Predicate<PropertyBuilder> predicate)

withProperties

public A withProperties(List<Property> properties)

withProperties

public A withProperties(Property... properties)

hasProperties
```
public boolean hasProperties()
```

addNewProperty

public TypeDefFluent.PropertiesNested<A> addNewProperty()

addNewPropertyLike

public TypeDefFluent.PropertiesNested<A> addNewPropertyLike(Property item)

setNewPropertyLike

public TypeDefFluent.PropertiesNested<A> setNewPropertyLike(int index,
                                                            Property item)

editProperty

public TypeDefFluent.PropertiesNested<A> editProperty(int index)

editFirstProperty

public TypeDefFluent.PropertiesNested<A> editFirstProperty()

editLastProperty

public TypeDefFluent.PropertiesNested<A> editLastProperty()

editMatchingProperty

public TypeDefFluent.PropertiesNested<A> editMatchingProperty(Predicate<PropertyBuilder> predicate)

addToConstructors

public A addToConstructors(int index,
                           Method item)

setToConstructors

public A setToConstructors(int index,
                           Method item)

addToConstructors

public A addToConstructors(Method... items)

addAllToConstructors

public A addAllToConstructors(Collection<Method> items)

removeFromConstructors

public A removeFromConstructors(Method... items)

removeAllFromConstructors

public A removeAllFromConstructors(Collection<Method> items)

removeMatchingFromConstructors

public A removeMatchingFromConstructors(Predicate<MethodBuilder> predicate)

buildConstructors

public List<Method> buildConstructors()

buildConstructor

public Method buildConstructor(int index)

buildFirstConstructor
```
public Method buildFirstConstructor()
```

buildLastConstructor
```
public Method buildLastConstructor()
```

buildMatchingConstructor

public Method buildMatchingConstructor(Predicate<MethodBuilder> predicate)

hasMatchingConstructor

public boolean hasMatchingConstructor(Predicate<MethodBuilder> predicate)

withConstructors

public A withConstructors(List<Method> constructors)

withConstructors

public A withConstructors(Method... constructors)

hasConstructors
```
public boolean hasConstructors()
```

addNewConstructor

public TypeDefFluent.ConstructorsNested<A> addNewConstructor()

addNewConstructorLike

public TypeDefFluent.ConstructorsNested<A> addNewConstructorLike(Method item)

setNewConstructorLike

public TypeDefFluent.ConstructorsNested<A> setNewConstructorLike(int index,
                                                                 Method item)

editConstructor

public TypeDefFluent.ConstructorsNested<A> editConstructor(int index)

editFirstConstructor

public TypeDefFluent.ConstructorsNested<A> editFirstConstructor()

editLastConstructor

public TypeDefFluent.ConstructorsNested<A> editLastConstructor()

editMatchingConstructor

public TypeDefFluent.ConstructorsNested<A> editMatchingConstructor(Predicate<MethodBuilder> predicate)

addToMethods

public A addToMethods(int index,
                      Method item)

setToMethods

public A setToMethods(int index,
                      Method item)

addToMethods

public A addToMethods(Method... items)

addAllToMethods

public A addAllToMethods(Collection<Method> items)

removeFromMethods

public A removeFromMethods(Method... items)

removeAllFromMethods

public A removeAllFromMethods(Collection<Method> items)

removeMatchingFromMethods

public A removeMatchingFromMethods(Predicate<MethodBuilder> predicate)

buildMethods
```
public List<Method> buildMethods()
```

buildMethod

public Method buildMethod(int index)

buildFirstMethod
```
public Method buildFirstMethod()
```

buildLastMethod
```
public Method buildLastMethod()
```

buildMatchingMethod

public Method buildMatchingMethod(Predicate<MethodBuilder> predicate)

hasMatchingMethod

public boolean hasMatchingMethod(Predicate<MethodBuilder> predicate)

withMethods

public A withMethods(List<Method> methods)

withMethods

public A withMethods(Method... methods)

hasMethods
```
public boolean hasMethods()
```

addNewMethod

public TypeDefFluent.MethodsNested<A> addNewMethod()

addNewMethodLike

public TypeDefFluent.MethodsNested<A> addNewMethodLike(Method item)

setNewMethodLike

public TypeDefFluent.MethodsNested<A> setNewMethodLike(int index,
                                                       Method item)

editMethod

public TypeDefFluent.MethodsNested<A> editMethod(int index)

editFirstMethod

public TypeDefFluent.MethodsNested<A> editFirstMethod()

editLastMethod

public TypeDefFluent.MethodsNested<A> editLastMethod()

editMatchingMethod

public TypeDefFluent.MethodsNested<A> editMatchingMethod(Predicate<MethodBuilder> predicate)

getOuterTypeName
```
public String getOuterTypeName()
```

withOuterTypeName

public A withOuterTypeName(String outerTypeName)

hasOuterTypeName
```
public boolean hasOuterTypeName()
```

addToInnerTypes

public A addToInnerTypes(int index,
                         TypeDef item)

setToInnerTypes

public A setToInnerTypes(int index,
                         TypeDef item)

addToInnerTypes

public A addToInnerTypes(TypeDef... items)

addAllToInnerTypes

public A addAllToInnerTypes(Collection<TypeDef> items)

removeFromInnerTypes

public A removeFromInnerTypes(TypeDef... items)

removeAllFromInnerTypes

public A removeAllFromInnerTypes(Collection<TypeDef> items)

removeMatchingFromInnerTypes

public A removeMatchingFromInnerTypes(Predicate<TypeDefBuilder> predicate)

buildInnerTypes

public List<TypeDef> buildInnerTypes()

buildInnerType

public TypeDef buildInnerType(int index)

buildFirstInnerType
```
public TypeDef buildFirstInnerType()
```

buildLastInnerType
```
public TypeDef buildLastInnerType()
```

buildMatchingInnerType

public TypeDef buildMatchingInnerType(Predicate<TypeDefBuilder> predicate)

hasMatchingInnerType

public boolean hasMatchingInnerType(Predicate<TypeDefBuilder> predicate)

withInnerTypes

public A withInnerTypes(List<TypeDef> innerTypes)

withInnerTypes

public A withInnerTypes(TypeDef... innerTypes)

hasInnerTypes
```
public boolean hasInnerTypes()
```

addNewInnerType

public A addNewInnerType(String fullyQualifiedName)

addNewInnerType

public TypeDefFluent.InnerTypesNested<A> addNewInnerType()

addNewInnerTypeLike

public TypeDefFluent.InnerTypesNested<A> addNewInnerTypeLike(TypeDef item)

setNewInnerTypeLike

public TypeDefFluent.InnerTypesNested<A> setNewInnerTypeLike(int index,
                                                             TypeDef item)

editInnerType

public TypeDefFluent.InnerTypesNested<A> editInnerType(int index)

editFirstInnerType

public TypeDefFluent.InnerTypesNested<A> editFirstInnerType()

editLastInnerType

public TypeDefFluent.InnerTypesNested<A> editLastInnerType()

editMatchingInnerType

public TypeDefFluent.InnerTypesNested<A> editMatchingInnerType(Predicate<TypeDefBuilder> predicate)

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

equals in class ModifierSupportFluent<A extends TypeDefFluent<A>>

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

hashCode in class ModifierSupportFluent<A extends TypeDefFluent<A>>

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

toString in class ModifierSupportFluent<A extends TypeDefFluent<A>>

Class TypeDefFluent<A extends TypeDefFluent<A>>

Nested Class Summary

Nested classes/interfaces inherited from class io.sundr.model.ModifierSupportFluent

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.sundr.model.ModifierSupportFluent

Methods inherited from class io.sundr.model.AttributeSupportFluent

Methods inherited from class io.sundr.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Detail

TypeDefFluent

TypeDefFluent

Method Detail

copyInstance

getKind

withKind

hasKind

getPackageName

withPackageName

hasPackageName

getName

withName

hasName

addToComments

setToComments

addToComments

addAllToComments

removeFromComments

removeAllFromComments

getComments

getComment

getFirstComment

getLastComment

getMatchingComment

hasMatchingComment

withComments

withComments

hasComments

addToAnnotations

setToAnnotations

addToAnnotations

addAllToAnnotations

removeFromAnnotations

removeAllFromAnnotations

removeMatchingFromAnnotations

buildAnnotations

buildAnnotation

buildFirstAnnotation

buildLastAnnotation

buildMatchingAnnotation

hasMatchingAnnotation

withAnnotations

withAnnotations

hasAnnotations

addNewAnnotation

addNewAnnotationLike

setNewAnnotationLike

editAnnotation

editFirstAnnotation

editLastAnnotation

editMatchingAnnotation

addToExtendsList

setToExtendsList

addToExtendsList

addAllToExtendsList

removeFromExtendsList

removeAllFromExtendsList

removeMatchingFromExtendsList

buildExtendsList

buildExtendsList

buildFirstExtendsList

buildLastExtendsList

buildMatchingExtendsList

hasMatchingExtendsList

withExtendsList

withExtendsList

hasExtendsList

addNewExtendsList