<p>I need to store a tree data structure in my database, for which I plan on using <a href="http://code.google.com/p/django-treebeard/" rel="noreferrer">django-treebeard</a> or possibly <a href="http://code.google.com/p/django-mptt/" rel="noreferrer">django-mptt</a>.  My source of confusion is that each node could be one of three different possible types: root nodes will always be a type A entity, leaf nodes a type C entity, and anything in between will be a type B entity.  I would like to know the best way to model this situation.</p>

<p><strong>update:</strong>  I first tried model inheritance, and I think that this could be the best way to go. Unfortunately django-treebeard's public API isn't really designed to handle this.  I ended up getting it to work with GenericForeignKey.  Thank you very much for the answers.</p>

Your three types are probably easiest handled as FK associations with the fundamental tree.
The tree can be homogenous -- class
```
MyNode
```
is a direct subclass of
```
treebeard.Node
```
.  Your node can have a flag (Root, Middle, Leaf) and FK's for A or B or C.  This allows you some SQL-like flexibility in querying MyNode instance.
This allows your tree to grow.  A node can start as a type C (leaf) and then morph to a type B (intermediate).  You change the status, and change the FK's.
The alternative is a bit more complex.
```
```
class MyA( treebeard.Node ):
    pass

class MyB( treebeard.Node ):
    pass

class MyC( treebeard.Node ):
    pass
```
```
In this case, you can't "morph" a node.  When a node starts as a
```
MyC
```
, and gets children, you have to remove the original
```
MyC
```
instance, and replace it with a
```
MyB
```
version that has a new node as a child.  This isn't impossible, but it can be painful.