%
    def title = classDoc.name() + (props.docTitle ? " (${props.docTitle})" : "")
    def isVisible = { it.isPublic() || (it.isProtected() && props.protectedScope == 'true') || (!it.isProtected() && !it.isPrivate() && props.packageScope == 'true') || props.privateScope == 'true' }
    def isVisibleExt = { t -> java.lang.reflect.Modifier.isPublic(t.modifiers) || java.lang.reflect.Modifier.isProtected(t.modifiers) }
    def visibleFields = classDoc.fields().findAll(isVisible)
    def visibleProperties = classDoc.properties() // props visible be defn
    def visibleMethods = classDoc.methods().findAll(isVisible)
    def visibleConstructors = classDoc.constructors().findAll(isVisible)
    def visibleNested = classDoc.innerClasses().findAll(isVisible)
    boolean hasFields = !classDoc.isAnnotationType() && visibleFields
    boolean hasProperties = !classDoc.isAnnotationType() && visibleProperties
    boolean hasElements = classDoc.isAnnotationType() && visibleFields
    boolean methodSummaryShown = visibleMethods
    boolean fieldSummaryShown = hasFields
    boolean hasEnumConstants = classDoc.enumConstants()
    def dolink = { t, boolean b ->
        boolean isArray = false
        if (!t || t instanceof String) {
            return classDoc.getDocUrl(t, b)
        }
        if (t instanceof org.codehaus.groovy.tools.groovydoc.ArrayClassDocWrapper) {
            t = t.delegate
            isArray = true
        }
        if (t instanceof org.codehaus.groovy.tools.groovydoc.SimpleGroovyClassDoc) {
            if (t.fullPathName == 'def') return classDoc.getDocUrl("java.lang.Object def", b)
            if (!t.qualifiedTypeName().contains("<") && t.name().size() > 1)
                return "" + (b ? t.qualifiedTypeName() : t.name()) + "" + (isArray ? "[]" : "")
        }
        return classDoc.getDocUrl(t.qualifiedTypeName(), b) + (isArray ? "[]" : "")
    }
    def linkfull = { t -> dolink(t, true) }
    def linkable = { t -> dolink(t, false) }
    def modifiersWithOptions = { t, boolean ignorePublic, boolean ignoreAbstract, boolean ignoreFinal=false, boolean ignoreStatic=false ->
        (t.isPrivate()?"private ":"") +
        (t.isPublic() && !ignorePublic?"public ":"") +
        (t.isProtected()?"protected ":"") +
        (t.isStatic() && !ignoreStatic ?"static ":"") +
        (t.isFinal() && !ignoreFinal?"final ":"") +
        (!ignoreAbstract && t.respondsTo('isAbstract') && t.isAbstract()?"abstract ":"")
    }
    def modifiers = { t -> modifiersWithOptions(t, classDoc.isGroovy(), false) }
    def modifiersBrief = { t ->
        (t.isPrivate()?"private ":"") +
        (t.isProtected()?"protected ":"") +
        (t.isStatic()?"static ":"")
    }
    def annotations = { t, sepChar ->
        t.annotations() ? t.annotations().collect{ it.isTypeAvailable()?'@'+linkable(it.type().typeName())+it.description():'@'+it.name()+it.description()}.join(sepChar) + sepChar : ''
    }
    def elementTypes = [
        "required":"true",
        "optional":"false"
    ]
    def isRequired = { f, v -> def req = f.constantValueExpression() == null; req.toString() == v }
    def upcase = { n -> n[0].toUpperCase() + n[1..-1] }
    def paramsOf = { n, boolean brief -> n.parameters().collect{ param -> (brief?'':annotations(param, '
')) + linkable(param.isTypeAvailable()?param.type():param.typeName()) + (param.vararg()?'... ':' ') + param.name() + (param.defaultValue() ? " = " + param.defaultValue():"") }.join(", ") }
    def rawType = { n -> def g = n.indexOf("<"); g >= 0 ? n.substring(0, g) : n }
    def nameFromParams = { n -> n.name() + '(' + n.parameters().collect{ param -> rawType(param.isTypeAvailable()?param.type().qualifiedTypeName():param.typeName()) }.join(', ') + ')' }
    def nameFromJavaParams = { n -> n.getName() + '(' + n.parameterTypes.collect{ param -> param.getName() }.join(', ') + ')' }
%>
${declaration?.replace(' ', ' ')}
<% if (classDoc.commentText()) { %>
    ${classDoc.commentText()}
<% } %>| Modifiers | Name | Description | 
|---|---|---|
| ${modifiersBrief(c) + c.typeSourceDescription} | ${linkable(c)} | ${c.firstSentenceCommentText()} | 
| Enum constant | Description | 
|---|---|
| ${ec.name()} | ${ec.firstSentenceCommentText()} | 
${c.typeSourceDescription} ${linkable(c)}${list.join(', ')}${c.typeSourceDescription} ${linkable(c)}${list.join(', ')}| Modifiers | Name | Description | 
|---|---|---|
| ${modifiersBrief(field) + linkable(field.type())} | ${field.name()} | ${field.firstSentenceCommentText()} | 
| Fields inherited from class | Fields | 
|---|
| Type | Name and description | 
|---|---|
| ${modifiersBrief(prop) + linkable(prop.type())} | ${prop.name()}${prop.firstSentenceCommentText()} | 
| Properties inherited from class | Properties | 
|---|
| Type | Name and Description | 
|---|---|
| ${modifiersBrief(element) + linkable(element.type())} | ${element.name()}${element.firstSentenceCommentText()} | 
| Constructor and description | 
|---|
| ${modifiersBrief(constructor)}${constructor.name()}(${paramsOf(constructor, true)})${constructor.firstSentenceCommentText()} | 
${c.typeSourceDescription} ${linkable(c)}${list.sort().join(', ')}| Type Params | Return Type | Name and description | 
|---|---|---|
| ${org.codehaus.groovy.tools.groovydoc.SimpleGroovyClassDoc.encodeAngleBrackets(method.typeParameters()) ?: ''} | ${modifiers(method)}${linkable(method.returnType())} | ${method.name()}(${paramsOf(method, true)})${method.firstSentenceCommentText()} | 
| Methods inherited from class | Name | 
|---|
${ec.commentText()}
${field.commentText()}
${prop.commentText()}
${element.commentText()}
${constructor.commentText()}
${method.commentText()}
${props.footer}
<% } %>