namespace boost {
  template<typename R, typename T1, typename T2, ..., typename TN, 
           typename Combiner = last_value<R>, typename Group = int, 
           typename GroupCompare = std::less<Group>, 
           typename SlotFunction = functionN<R, T1, T2, ..., TN>, 
           typename ThreadingModel = signalslib::auto_threaded> 
    class signalN;
  template<typename Signature, typename Combiner = last_value<R>, 
           typename Group = int, typename GroupCompare = std::less<Group>, 
           typename SlotFunction = function<Signature>, 
           typename ThreadingModel = signalslib::auto_threaded> 
    class signal;
  namespace signalslib {

    enum connect_position { at_front, at_back };
  }
}

namespace boost {
  namespace signalslib {
    class signal_base;
  }
}

namespace boost {
  template<typename R, typename T1, typename T2, ..., typename TN, 
           typename SlotFunction = functionN<R, T1, T2, ..., TN> > 
    class slotN;
  template<typename Signature, typename SlotFunction = function<Signature> > 
    class slot;
}

namespace boost {
  class expired_slot;
  namespace signalslib {
    class slot_base;
  }
}

namespace boost {
  namespace signalslib {
    class connection;
    void swap(connection&, connection&);
    class scoped_connection;
  }
}

namespace boost {
  namespace signalslib {
    class shared_connection_block;
  }
}

namespace boost {
  template<typename T> class last_value;

  template<> class last_value<void>;
  template<typename T> class last_value<optional<T>>;

  class no_slots_error;
}

namespace boost {
  namespace signalslib {
    class auto_threaded;
  }
}

namespace boost {
  namespace signalslib {
    class single_threaded;
  }
}

namespace boost {
  namespace signalslib {
    class multi_threaded;
  }
}

namespace boost {
  template<typename T> class predestructing_deleter;
  template<typename T> shared_ptr<T> deconstruct_ptr(T*);
  template<typename T, typename D> shared_ptr<T> deconstruct_ptr(T*, D);
}

namespace boost {
  class postconstructible;
}

namespace boost {
  class predestructible;
}