Fluent NHibernate mapowanie klas z klasą bazową.

Hej, mam taką sytuację:

public enum BaseType
{
  Type1,
  Type2
}

public abstract class Base
{
   public virtual int IntValue {get; set;}
   public virtual BaseType BaseType {get;}
} 

public class Type1Class: Base
{
  public virtual string StrValue {get;set;}
  public override BaseType BaseType { get { return BaseType.Type1;}}
}

public class Type2Class: Base
{
  public virtual decimal DecValue {get;set;}
    public override BaseType BaseType { get { return BaseType.Type2;}}
}

Chciałbym teraz zrobić tak mapowanie, żeby powstały mi dwie tabele: Type1Classes i Type2Classes. I z tego, co rozumiem z dokumentacji, właśnie tak robię. Ale w rzeczywistości powstają mi trzy tabele: Base, Type1Classes i Type2Classes. W tabeli Base mam wspólne kolumny dla wszystkich i dwa rekordy. W pozostałych tabelach mam po jednym rekordzie i wszystko jest połączone ze sobą za pomocą Idków. I niby wszystko jest ok, ale chciałbym mieć dwie tabele.

Moje mapowanie wygląda tak:

public class BaseMap: ClassMap<BaseMap>
    {
        public BaseMap()
        {
            Map(x => x.IntValue).Not.Nullable();
            Map(x => x.BaseType).CustomType<BaseType>();
        }
    }

public class Type1Map: SubclassMap<Type1Class>
    {
        public Type1Map()
        {
            Table("type1classes");
            Map(x => x.StrValue);
        }
    }

public class Type2Map: SubclassMap<Type2Class>
    {
        public Type2Map()
        {
            Table("type2classes");
            Map(x => x.DecValue);
        }
    }

Co tu jest nie tak?

To nie zrozumiałeś dokumentacji.
Dawno nie używałem Fluent NHibernate więc mogę się mylić, a nie mam jak obecnie przetestować, ale z pamięci:
Usuń BaseMap skoro nie potrzebujesz tego jako tabeli.
SubclassMap zmień na ClassMap.

Wtedy się czepia, że używam niemapowanej klasy - Base

Ten cały BaseType jest bez sensu, bo to ani w klasach ani w tabelach nie pomaga.

Type1Map i Type2Map powinny mieć wywołane dodatkowo Abstract();, natomiast BaseMap powinno mieć UseUnionSubclassForInheritanceMapping(); no i oczywiście jakieś Id().

public class BaseMap : ClassMap<Base>
{
    public BaseMap()
    {
        UseUnionSubclassForInheritanceMapping();
        Id(x => x.Id).GeneratedBy.Native();
        Map(x => x.IntValue).Not.Nullable();
        Map(x => x.BaseType).CustomType<BaseType>();
    }
}

public class Type1Map : SubclassMap<Type1Class>
{
    public Type1Map()
    {
        Table("type1classes");
        Abstract();
        Map(x => x.StrValue);
    }
}

public class Type2Map : SubclassMap<Type2Class>
{
    public Type2Map()
    {
        Table("type2classes");
        Abstract();
        Map(x => x.DecValue);
    }
}