         super.init()
     }
 
+    /// Lists all known classes in the project
     lazy var classes: [Type] = {
-        return self.types.filter { type in
-            let isNotClass = type is Struct || type is Enum || type is Protocol
-            return !isNotClass && !type.isExtension
-        }
+        return self.types.filter { $0.isClass }
     }()
 
+    /// lists all known types, excluding protocols
     lazy var all: [Type] = {
         return self.types.filter { !($0 is Protocol) }
     }()
 
+    /// Lists all known protocols
     lazy var protocols: [Type] = {
         return self.types.filter { $0 is Protocol }
     }()
 
+    /// Lists all known structs
     lazy var structs: [Type] = {
         return self.types.filter { $0 is Struct }
     }()
 
+    /// Lists all known enums
     lazy var enums: [Type] = {
         return self.types.filter { $0 is Enum }
     }()
 
+    /// Lists all encountered types, even if they are not known e.g. Apple or 3rd party frameworks
     lazy var based: [String: [Type]] = {
         var content = [String: [Type]]()
         self.all.forEach { type in

import Foundation
import Stencil

/// types.all <- lists all types, excluding protocols
/// types.classes <- lists all classes
/// types.structs <- lists all structs
/// types.enums <- lists all enums
/// types.protocols <- lists all protocols (that were defined in the project)
/// types.inheriting.BaseClass <- lists all classes inheriting from known BaseClass
/// types.implementing.BaseProtocol <- lists all types implementing known BaseProtocol
/// types.based.BaseClassOrProtocol <- lists all types inheriting from given BaseClass or implementing given Protocol
private class TypesReflectionBox: NSObject {
    private let types: [Type]



            baseType.based.keys.forEach {  type.based[$0] = $0 }

            if baseType.isClass {
                type.inherits[name] = name
                baseType.inherits.keys.forEach {  type.inherits[$0] = $0 }
            } else if baseType is Protocol {
