ClassToAPI

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val ArrayRef: SimpleType

val Empty: EmptyType

val NothingRef: SimpleType

val Private: Private

val Protected: Protected

val Public: Public

val ThisRef: This

val Throws: SimpleType

val Unqualified: Unqualified

def access(i: Int, pkg: Option[String]): Access

def annotated(t: SimpleType, annots: Array[Annotation]): Type

def annotation(a: Annotation): Annotation

def annotations(a: Array[Annotation]): Array[Annotation]

def apply(c: Seq[Class[_]]): Seq[ClassLike]

def array(tpe: Type): SimpleType

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def constructorToDef(enclPkg: Option[String])(c: Constructor[_]): Def

def defLike[T <: GenericDeclaration](name: String, mods: Int, annots: Array[Annotation], tps: Array[TypeVariable[T]], paramAnnots: Array[Array[Annotation]], paramTypes: Array[Type], retType: Option[Type], exceptions: Array[Type], varArgs: Boolean, enclPkg: Option[String]): Def

def emptyClassMap: ClassMap

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exceptionAnnotations(exceptions: Array[Type]): Array[Annotation]

def fieldToDef(c: Class[_], cf: ⇒ ClassFile, enclPkg: Option[String])(f: Field): FieldLike

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isStatic(a: Member): Boolean

def isStatic(c: Class[_]): Boolean

def isTopLevel(c: Class[_]): Boolean

def javaAnnotation(s: String): AnnotationArgument

def lzy[T <: AnyRef](t: ⇒ T): Lazy[T]

def merge[T](of: Class[_], self: Seq[T], public: Seq[T], f: (T) ⇒ Seq[ClassDefinition], splitStatic: (Seq[T]) ⇒ (Seq[T], Seq[T]), isInherited: (T) ⇒ Boolean): Defs

def mergeMap[T <: Member](of: Class[_], self: Seq[T], public: Seq[T], f: (T) ⇒ ClassDefinition): Defs

def methodToDef(enclPkg: Option[String])(m: Method): Def

def modifiers(i: Int): Modifiers

def name(gd: GenericDeclaration): String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def packageAndName(name: String): (Option[String], String)

def packageAndName(c: Class[_]): (Option[String], String)

def packageName(c: Class[_]): Option[String]

def packagePrivate(pkg: Option[String]): Access

def packages(c: Seq[Class[_]]): Set[String]

def parameter(annots: Array[Annotation], parameter: Type, varArgs: Boolean): MethodParameter

def pathFromString(s: String): Path

def pathFromStrings(ss: Seq[String]): Path

def primitive(name: String): SimpleType

def process(c: Seq[Class[_]]): (Seq[ClassLike], Set[(Class[_], Class[_])])

def reduceHash(in: Array[Byte]): Int

def reference(t: Type): SimpleType

def reference(s: String): SimpleType

def reference(c: Class[_]): SimpleType

def referenceP(t: ParameterizedType): Parameterized

def splitStatic[T <: Member](defs: Seq[T]): (Seq[T], Seq[T])

def structure(c: Class[_], enclPkg: Option[String], cmap: ClassMap): (Structure, Structure)

Returns the (static structure, instance structure, inherited classes) for c.

final def synchronized[T0](arg0: ⇒ T0): T0

def toDefinitions(cmap: ClassMap)(c: Class[_]): Seq[ClassLikeDef]

def toDefinitions0(c: Class[_], cmap: ClassMap): Seq[ClassLikeDef]

def toString(): String

def typeParameter[T <: GenericDeclaration](tp: TypeVariable[T]): TypeParameter

def typeParameters[T <: GenericDeclaration](tps: Array[TypeVariable[T]]): Array[TypeParameter]

def typeVariable[T <: GenericDeclaration](tv: TypeVariable[T]): String

def types(ts: Seq[Type]): Array[Type]

def upperBounds(ts: Array[Type]): Type

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def fieldToDef(enclPkg: Option[String])(f: Field): FieldLike

def parents(c: Class[_]): Seq[Type]