public class UserSpecialization : PersonSpecialization, IUserSpecialization
{
    public static readonly string SpecializationNameValue = "User";

    public UserSpecialization()
    {
        Roles = new Collection<IRole>();
    }

    public virtual IEnumerable<IRole> Roles
    {
        get;
        set;
    }
}

public abstract class PersonSpecialization : DomainObjectOfInt32, IPersonSpecialization
{
    public virtual IPerson Person { get; set; }
    public virtual string SpecializationName { get; protected set; }
}

public class Person : DomainObjectOfInt32, IPerson, IAuditable
{
    public Person()
    {
        Specializations = new List<IPersonSpecialization>();
    }

    public virtual IList<IPersonSpecialization> Specializations { get; protected set; }
}

public abstract class Role : DomainObjectOfInt32, IRole, IAuditable
{
    public Role(string roleName)
        : this()
    {
        Name = roleName;
    }
    protected Role()
    {
        AssignedUsers = new Collection<IUserSpecialization>();
    }

    public virtual ICollection<IUserSpecialization> AssignedUsers
    {
        get;
        protected set; }
}

public class PersonMap : ClassMap<Person>
{
    public PersonMap()
    {
        Id(x => x.Id).GeneratedBy.Identity();
        HasMany<PersonSpecialization>(c => c.Specializations)
            .Cascade.AllDeleteOrphan();
    }
}

public class RoleMap : ClassMap<Role>
{
    public RoleMap()
    {
        Id(x => x.Id).GeneratedBy.Identity();
        HasManyToMany<UserSpecialization>(x => x.AssignedUsers).Table("UserRole");
        DiscriminateSubClassesOnColumn("Type");
    }
}

public class PersonSpecializationMap : ClassMap<PersonSpecialization>
{
    public PersonSpecializationMap()
    {
        Table("PersonSpecialization");

        Id(c => c.Id).GeneratedBy.Identity();

        DiscriminateSubClassesOnColumn<string>("SpecializationName");

        Map(x => x.SpecializationName).ReadOnly();

        References<Person>(c => c.Person);
    }
}

public class UserSpecializationMap : SubclassMap<UserSpecialization>
{
   public UserSpecializationMap()
    {
        Table("User");

        DiscriminatorValue(UserSpecialization.SpecializationNameValue);

        Join("[User]", joined =>
        {
            joined.Map(c => c.UserName, "Username");

            joined.HasManyToMany<Role>(x => x.Roles)
                .Table("UserRole");
        });
    }
}