diff --git a/src/datatypes/place.cpp b/src/datatypes/place.cpp
index 84f4818..aa14d8b 100644
--- a/src/datatypes/place.cpp
+++ b/src/datatypes/place.cpp
@@ -1,110 +1,124 @@
 /*
     Copyright (C) 2018 Volker Krause <vkrause@kde.org>
 
     This program is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This program is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "place.h"
 #include "datatypes_p.h"
 
 #include <cmath>
 
 using namespace KItinerary;
 
 namespace KItinerary {
 
 class GeoCoordinatesPrivate : public QSharedData
 {
 public:
     float latitude = NAN;
     float longitude = NAN;
 };
 
 KITINERARY_MAKE_SIMPLE_CLASS(GeoCoordinates)
 KITINERARY_MAKE_PROPERTY(GeoCoordinates, float, latitude, setLatitude)
 KITINERARY_MAKE_PROPERTY(GeoCoordinates, float, longitude, setLongitude)
 
 bool GeoCoordinates::isValid() const
 {
     return !std::isnan(d->latitude) && !std::isnan(d->longitude);
 }
 
 
 class PostalAddressPrivate : public QSharedData
 {
 public:
     QString streetAddress;
     QString addressLocality;
     QString postalCode;
     QString addressCountry;
 };
 
 KITINERARY_MAKE_SIMPLE_CLASS(PostalAddress)
 KITINERARY_MAKE_PROPERTY(PostalAddress, QString, streetAddress, setStreeAddress)
 KITINERARY_MAKE_PROPERTY(PostalAddress, QString, addressLocality, setAddressLocality)
 KITINERARY_MAKE_PROPERTY(PostalAddress, QString, postalCode, setPostalCode)
 KITINERARY_MAKE_PROPERTY(PostalAddress, QString, addressCountry, setAddressCountry)
 
 
 class PlacePrivate : public QSharedData
 {
     KITINERARY_PRIVATE_ABSTRACT_GADGET(Place)
 public:
     QString name;
     PostalAddress address;
     GeoCoordinates geo;
 };
 
 KITINERARY_MAKE_ABSTRACT_CLASS(Place)
 KITINERARY_MAKE_PROPERTY(Place, QString, name, setName)
 KITINERARY_MAKE_PROPERTY(Place, PostalAddress, address, setAddress)
 KITINERARY_MAKE_PROPERTY(Place, GeoCoordinates, geo, setGeo)
 
 
 class AirportPrivate : public PlacePrivate
 {
     KITINERARY_PRIVATE_GADGET(Airport)
 public:
     QString iataCode;
 };
 
 KITINERARY_MAKE_SUB_CLASS(Airport, Place)
 KITINERARY_MAKE_PROPERTY(Airport, QString, iataCode, setIataCode)
 
 class TrainStationPrivate : public PlacePrivate
 {
     KITINERARY_PRIVATE_GADGET(TrainStation)
 };
 KITINERARY_MAKE_SUB_CLASS(TrainStation, Place)
 
 class BusStationPrivate : public PlacePrivate
 {
     KITINERARY_PRIVATE_GADGET(BusStation)
 };
 KITINERARY_MAKE_SUB_CLASS(BusStation, Place)
 class LodgingBusinessPrivate : public PlacePrivate
 {
     KITINERARY_PRIVATE_GADGET(LodgingBusiness)
 };
 KITINERARY_MAKE_SUB_CLASS(LodgingBusiness, Place)
 
 }
 
+class TouristAttractionPrivate: public PlacePrivate
+{
+    KITINERARY_PRIVATE_GADGET(TouristAttraction)
+};
+KITINERARY_MAKE_SUB_CLASS(TouristAttraction, Place)
+
+class FoodEstablishmentPrivate: public PlacePrivate
+{
+    KITINERARY_PRIVATE_GADGET(FoodEstablishment)
+};
+KITINERARY_MAKE_SUB_CLASS(FoodEstablishment, Place)
+
+
+
 template <>
 KItinerary::PlacePrivate *QExplicitlySharedDataPointer<KItinerary::PlacePrivate>::clone()
 {
     return d->clone();
 }
 
 #include "moc_place.cpp"
diff --git a/src/datatypes/place.h b/src/datatypes/place.h
index daea7fd..d6491c3 100644
--- a/src/datatypes/place.h
+++ b/src/datatypes/place.h
@@ -1,118 +1,136 @@
 /*
     Copyright (C) 2018 Volker Krause <vkrause@kde.org>
 
     This program is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This program is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef KITINERARY_PLACE_H
 #define KITINERARY_PLACE_H
 
 #include "kitinerary_export.h"
 
 #include "datatypes.h"
 
 class QVariant;
 
 namespace KItinerary {
 
 class GeoCoordinatesPrivate;
 
 /** Geographic coordinates.
  *  @see https://schema.org/GeoCoordinates
  */
 class KITINERARY_EXPORT GeoCoordinates
 {
     KITINERARY_GADGET(GeoCoordinates)
     KITINERARY_PROPERTY(float, latitude, setLatitude)
     KITINERARY_PROPERTY(float, longitude, setLongitude)
 public:
     bool isValid() const;
 private:
     QExplicitlySharedDataPointer<GeoCoordinatesPrivate> d;
 };
 
 class PostalAddressPrivate;
 
 /** Postal address.
  *  @see https://schema.org/PostalAddress
  */
 class KITINERARY_EXPORT PostalAddress
 {
     KITINERARY_GADGET(PostalAddress)
     KITINERARY_PROPERTY(QString, streetAddress, setStreeAddress)
     KITINERARY_PROPERTY(QString, addressLocality, setAddressLocality)
     KITINERARY_PROPERTY(QString, postalCode, setPostalCode)
     KITINERARY_PROPERTY(QString, addressCountry, setAddressCountry)
 private:
     QExplicitlySharedDataPointer<PostalAddressPrivate> d;
 };
 
 class PlacePrivate;
 
 /** Base class for places.
  *  @see https://schema.org/Place
  */
 class KITINERARY_EXPORT Place
 {
     KITINERARY_ABSTRACT_GADGET(Place)
     KITINERARY_PROPERTY(QString, name, setName)
     KITINERARY_PROPERTY(KItinerary::PostalAddress, address, setAddress)
     KITINERARY_PROPERTY(KItinerary::GeoCoordinates, geo, setGeo)
 protected:
     QExplicitlySharedDataPointer<PlacePrivate> d;
 };
 
 /** Airport.
  *  @see https://schema.org/Airport.
  */
 class KITINERARY_EXPORT Airport : public Place
 {
     KITINERARY_GADGET(Airport)
     KITINERARY_PROPERTY(QString, iataCode, setIataCode)
 };
 
 /** Train station.
  *  @see https://schema.org/TrainStation
  */
 class KITINERARY_EXPORT TrainStation : public Place
 {
     KITINERARY_GADGET(TrainStation)
 };
 
 /** Bus station.
  *  @see https://schema.org/BusStation
  */
 class KITINERARY_EXPORT BusStation : public Place
 {
     KITINERARY_GADGET(BusStation)
 };
 
 /** Hotel.
  *  @see https://schema.org/LodgingBusiness
  */
 class KITINERARY_EXPORT LodgingBusiness: public Place
 {
     KITINERARY_GADGET(LodgingBusiness)
 };
 
+/** Tourist attraction (e.g. Museum, sight, etc.).
+ * @see https://schema.org/TouristAttraction
+ */
+class KITINERARY_EXPORT TouristAttraction: public Place
+{
+    KITINERARY_GADGET(TouristAttraction)
+};
+
+/** Food-related business (such as a restaurant, or a bakery).
+ * @see https://schema.org/FoodEstablishment
+ */
+class KITINERARY_EXPORT FoodEstablishment: public Place
+{
+    KITINERARY_GADGET(FoodEstablishment)
+};
+
 }
 
 Q_DECLARE_METATYPE(KItinerary::GeoCoordinates)
 Q_DECLARE_METATYPE(KItinerary::PostalAddress)
 Q_DECLARE_METATYPE(KItinerary::Airport)
 Q_DECLARE_METATYPE(KItinerary::TrainStation)
 Q_DECLARE_METATYPE(KItinerary::BusStation)
 Q_DECLARE_METATYPE(KItinerary::LodgingBusiness)
+Q_DECLARE_METATYPE(KItinerary::TouristAttraction)
+Q_DECLARE_METATYPE(KItinerary::FoodEstablishment)
 
 #endif // KITINERARY_PLACE_H
diff --git a/src/jsonlddocument.cpp b/src/jsonlddocument.cpp
index 5ac207f..eafd4f4 100644
--- a/src/jsonlddocument.cpp
+++ b/src/jsonlddocument.cpp
@@ -1,310 +1,312 @@
 /*
    Copyright (c) 2017 Volker Krause <vkrause@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #include "jsonlddocument.h"
 #include "logging.h"
 
 #include <datatypes/bustrip.h>
 #include <datatypes/flight.h>
 #include <datatypes/organization.h>
 #include <datatypes/place.h>
 #include <datatypes/reservation.h>
 #include <datatypes/ticket.h>
 #include <datatypes/traintrip.h>
 
 #include <QDateTime>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QMetaProperty>
 #include <QUrl>
 #include <QTimeZone>
 
 #include <cmath>
 
 using namespace KItinerary;
 
 static QVariant createInstance(const QJsonObject &obj);
 
 // Eurowings workarounds...
 static const char *fallbackDateTimePattern[] = {
     "yyyy-MM-dd HH:mm:ss",
     "yyyy-MM-dd HH:mm",
     "MM-dd-yyyy HH:mm" // yes, seriously ;(
 };
 static const auto fallbackDateTimePatternCount = sizeof(fallbackDateTimePattern) / sizeof(const char *);
 
 static QVariant propertyValue(const QMetaProperty &prop, const QJsonValue &v)
 {
     switch (prop.type()) {
     case QVariant::String:
         return v.toString();
     case QVariant::Date:
         return QDate::fromString(v.toString(), Qt::ISODate);
     case QVariant::DateTime:
     {
         QDateTime dt;
         if (v.isObject()) {
             const auto dtObj = v.toObject();
             if (dtObj.value(QLatin1String("@type")).toString() == QLatin1String("QDateTime")) {
                 dt = QDateTime::fromString(dtObj.value(QLatin1String("@value")).toString(), Qt::ISODate);
                 dt.setTimeZone(QTimeZone(dtObj.value(QLatin1String("timezone")).toString().toUtf8()));
             }
         } else {
             auto str = v.toString();
             dt = QDateTime::fromString(str, Qt::ISODate);
             for (unsigned int i = 0; i < fallbackDateTimePatternCount && dt.isNull(); ++i) {
                 dt = QDateTime::fromString(str, QString::fromLatin1(fallbackDateTimePattern[i]));
             }
             if (dt.isNull()) {
                 qCDebug(Log) << "Datetime parsing failed for" << str;
             }
         }
 
         return dt;
     }
     case QVariant::Double:
         return v.toDouble();
     case QVariant::Url:
         return QUrl(v.toString());
     default:
         break;
     }
     if (prop.type() == qMetaTypeId<float>()) {
         return v.toDouble();
     }
     return createInstance(v.toObject());
 }
 
 template<typename T>
 static QVariant createInstance(const QJsonObject &obj)
 {
     T t;
     for (auto it = obj.begin(); it != obj.end(); ++it) {
         if (it.key().startsWith(QLatin1Char('@'))) {
             continue;
         }
         const auto idx = T::staticMetaObject.indexOfProperty(it.key().toLatin1().constData());
         if (idx < 0) {
             qCDebug(Log) << "property" << it.key() << "could not be set on object of type" << T::staticMetaObject.className();
             continue;
         }
         const auto prop = T::staticMetaObject.property(idx);
         const auto value = propertyValue(prop, it.value());
         prop.writeOnGadget(&t, value);
     }
     return QVariant::fromValue(t);
 }
 
 #define MAKE_FACTORY(Class) \
     if (type == QLatin1String(#Class)) \
         return createInstance<Class>(obj)
 
 static QVariant createInstance(const QJsonObject &obj)
 {
     const auto type = obj.value(QLatin1String("@type")).toString();
     MAKE_FACTORY(GeoCoordinates);
     MAKE_FACTORY(Airline);
     MAKE_FACTORY(Airport);
     MAKE_FACTORY(FlightReservation);
     MAKE_FACTORY(Flight);
     MAKE_FACTORY(LodgingBusiness);
     MAKE_FACTORY(LodgingReservation);
+    MAKE_FACTORY(FoodEstablishment);
+    MAKE_FACTORY(TouristAttraction);
     MAKE_FACTORY(PostalAddress);
     MAKE_FACTORY(Seat);
     MAKE_FACTORY(Ticket);
     MAKE_FACTORY(TrainStation);
     MAKE_FACTORY(TrainTrip);
     MAKE_FACTORY(TrainReservation);
     MAKE_FACTORY(BusStation);
     MAKE_FACTORY(BusTrip);
     MAKE_FACTORY(BusReservation);
     MAKE_FACTORY(Organization);
     return {};
 }
 
 #undef MAKE_FACTORY
 
 QVector<QVariant> JsonLdDocument::fromJson(const QJsonArray &array)
 {
     QVector<QVariant> l;
     l.reserve(array.size());
     for (const auto &obj : array) {
         const auto v = createInstance(obj.toObject());
         if (!v.isNull()) {
             l.push_back(v);
         }
     }
     return l;
 }
 
 static bool valueIsNull(const QVariant &v)
 {
     if (v.type() == QVariant::Url) {
         return !v.toUrl().isValid();
     }
     if (v.type() == qMetaTypeId<float>()) {
         return std::isnan(v.toFloat());
     }
     return v.isNull();
 }
 
 static QJsonValue toJson(const QVariant &v)
 {
     const auto mo = QMetaType(v.userType()).metaObject();
     if (!mo) {
         // basic types
         switch (v.type()) {
         case QVariant::String:
             return v.toString();
         case QVariant::Double:
             return v.toDouble();
         case QVariant::Int:
             return v.toInt();
         case QVariant::Date:
             return v.toDate().toString(Qt::ISODate);
         case QVariant::DateTime:
         {
             const auto dt = v.toDateTime();
             if (dt.timeSpec() == Qt::TimeZone) {
                 QJsonObject dtObj;
                 dtObj.insert(QStringLiteral("@type"), QStringLiteral("QDateTime"));
                 dtObj.insert(QStringLiteral("@value"), dt.toString(Qt::ISODate));
                 dtObj.insert(QStringLiteral("timezone"), QString::fromUtf8(dt.timeZone().id()));
                 return dtObj;
             }
             return v.toDateTime().toString(Qt::ISODate);
         }
         case QVariant::Url:
             return v.toUrl().toString();
         default:
             break;
         }
         if (v.userType() == qMetaTypeId<float>()) {
             return v.toFloat();
         }
         qCDebug(Log) << "unhandled value:" << v;
         return {};
     }
 
     // composite types
     QJsonObject obj;
     obj.insert(QStringLiteral("@type"), JsonLdDocument::readProperty(v, "className").toString());
     for (int i = 0; i < mo->propertyCount(); ++i) {
         const auto prop = mo->property(i);
         if (!prop.isStored()) {
             continue;
         }
         const auto value = prop.readOnGadget(v.constData());
         if (!valueIsNull(value)) {
             const auto jsVal = toJson(value);
             if (jsVal.type() != QJsonValue::Null) {
                 obj.insert(QString::fromUtf8(prop.name()), jsVal);
             }
         }
     }
     if (obj.size() > 1) {
         return obj;
     }
 
     return {};
 }
 
 QJsonArray JsonLdDocument::toJson(const QVector<QVariant> &data)
 {
     QJsonArray a;
     for (const auto &d : data) {
         const auto value = toJson(d);
         if (!value.isObject()) {
             continue;
         }
         auto obj = value.toObject();
         obj.insert(QStringLiteral("@context"), QStringLiteral("http://schema.org"));
         a.push_back(obj);
     }
     return a;
 }
 
 QVariant JsonLdDocument::readProperty(const QVariant &obj, const char *name)
 {
     const auto mo = QMetaType(obj.userType()).metaObject();
     if (!mo) {
         return {};
     }
 
     const auto idx = mo->indexOfProperty(name);
     if (idx < 0) {
         return {};
     }
 
     const auto prop = mo->property(idx);
     return prop.readOnGadget(obj.constData());
 }
 
 void JsonLdDocument::writeProperty(QVariant &obj, const char *name, const QVariant &value)
 {
     const auto mo = QMetaType(obj.userType()).metaObject();
     if (!mo) {
         return;
     }
 
     const auto idx = mo->indexOfProperty(name);
     if (idx < 0) {
         return;
     }
 
     const auto prop = mo->property(idx);
     prop.writeOnGadget(obj.data(), value);
 }
 
 void JsonLdDocument::removeProperty(QVariant &obj, const char *name)
 {
     writeProperty(obj, name, QVariant());
 }
 
 QVariant JsonLdDocument::apply(const QVariant& lhs, const QVariant& rhs)
 {
     if (rhs.isNull()) {
         return lhs;
     }
     if (lhs.isNull()) {
         return rhs;
     }
     if (lhs.userType() != rhs.userType()) {
         qCWarning(Log) << "type mismatch during merging:" << lhs << rhs;
         return {};
     }
 
     auto res = lhs;
     const auto mo = QMetaType(res.userType()).metaObject();
     for (int i = 0; i < mo->propertyCount(); ++i) {
         const auto prop = mo->property(i);
         if (!prop.isStored()) {
             continue;
         }
         auto pv = prop.readOnGadget(rhs.constData());
         if (QMetaType(pv.userType()).metaObject()) {
             pv = apply(prop.readOnGadget(lhs.constData()), pv);
         }
         if (!pv.isNull()) {
             prop.writeOnGadget(res.data(), pv);
         }
     }
 
     return res;
 }