removed QOrganizerItemLocalId - QOrganizerItemId is used instead

- unit tests are broken for the moment
- symbian backend is not modified yet

64 files changed, 719 insertions, 1023 deletions

diff --git a/examples/calendardemo/src/calendardemo.cpp b/examples/calendardemo/src/calendardemo.cpp
index 4bb2f45071..f3b170e6f9 100644
--- a/examples/calendardemo/src/calendardemo.cpp
+++ b/examples/calendardemo/src/calendardemo.cpp
@@ -406,7 +406,7 @@ void CalendarDemo::exportItems()
 void CalendarDemo::deleteAllEntries()
 {
     // Fetch all the entries
-    QList<QOrganizerItemLocalId> ids = m_manager->itemIds();
+    QList<QOrganizerItemId> ids = m_manager->itemIds();
     
     if(ids.count()) {
         m_remReq.setItemIds(ids);
diff --git a/examples/calendardemo/src/daypage.cpp b/examples/calendardemo/src/daypage.cpp
index 33760ffcaf..ca537b9585 100644
--- a/examples/calendardemo/src/daypage.cpp
+++ b/examples/calendardemo/src/daypage.cpp
@@ -206,7 +206,7 @@ void DayPage::removeItem()
     if (organizerItem.isEmpty())
         return;
 
-    m_manager->removeItem(organizerItem.localId());
+    m_manager->removeItem(organizerItem.id());
     if (m_manager->error())
         QMessageBox::information(this, "Failed!", QString("Failed to remove item!\n(error code %1)").arg(m_manager->error()));
     else
diff --git a/examples/calendardemo/src/monthpage.cpp b/examples/calendardemo/src/monthpage.cpp
index ed13aa6d19..593be27a21 100644
--- a/examples/calendardemo/src/monthpage.cpp
+++ b/examples/calendardemo/src/monthpage.cpp
@@ -162,7 +162,7 @@ void MonthPage::removeItem()
     if (organizerItem.isEmpty())
         return;
 
-    m_manager->removeItem(organizerItem.localId());
+    m_manager->removeItem(organizerItem.id());
     refresh();
 }
 
diff --git a/examples/todo/window.cpp b/examples/todo/window.cpp
index 1d994bfd7a..9d435df9d1 100644
--- a/examples/todo/window.cpp
+++ b/examples/todo/window.cpp
@@ -112,7 +112,7 @@ void Window::deleteTodo()
         QVariant variant = items.at(0)->data(Qt::UserRole);
         if (variant.canConvert<QOrganizerTodo>()) {
             QOrganizerTodo theTodo = variant.value<QOrganizerTodo>();
-            manager->removeItem(theTodo.localId());
+            manager->removeItem(theTodo.id());
             refreshList();
         }
     }
diff --git a/plugins/declarative/organizer/qdeclarativeorganizeritemdetail_p.h b/plugins/declarative/organizer/qdeclarativeorganizeritemdetail_p.h
index 93484f5c46..2ba3d57af7 100644
--- a/plugins/declarative/organizer/qdeclarativeorganizeritemdetail_p.h
+++ b/plugins/declarative/organizer/qdeclarativeorganizeritemdetail_p.h
@@ -346,13 +346,13 @@ public:
     void setParentId(uint newParentId)
     {
         if (newParentId != parentId() && !readOnly()) {
-            m_detail.setValue(QOrganizerItemParent::FieldParentLocalId, newParentId);
+            m_detail.setValue(QOrganizerItemParent::FieldParentId, newParentId);
             emit valueChanged();
         }
     }
     uint parentId() const
     {
-        return m_detail.variantValue(QOrganizerItemParent::FieldParentLocalId).toInt();
+        return m_detail.variantValue(QOrganizerItemParent::FieldParentId).toInt();
     }
 
 
diff --git a/plugins/declarative/organizer/qdeclarativeorganizeritemfilter.cpp b/plugins/declarative/organizer/qdeclarativeorganizeritemfilter.cpp
index c703d2e44f..3f189ffac4 100644
--- a/plugins/declarative/organizer/qdeclarativeorganizeritemfilter.cpp
+++ b/plugins/declarative/organizer/qdeclarativeorganizeritemfilter.cpp
@@ -47,12 +47,12 @@
 QOrganizerItemFilter QDeclarativeOrganizerItemLocalIdFilter::filter() const
 {
     QOrganizerItemLocalIdFilter f;
-    QList<QOrganizerItemLocalId> ids;
+    QList<QOrganizerItemId> ids;
 
     foreach(const QVariant& id, m_ids) {
         QOrganizerItemId itemId = QDeclarativeOrganizerModel::itemIdFromHash(id.value<uint>());
-        if (!itemId.localId().isNull())
-            ids << itemId.localId();
+        if (!itemId.isNull())
+            ids << itemId;
     }
 
     f.setIds(ids);
diff --git a/plugins/declarative/organizer/qdeclarativeorganizermodel.cpp b/plugins/declarative/organizer/qdeclarativeorganizermodel.cpp
index ecb546689a..f7c7bb5a87 100644
--- a/plugins/declarative/organizer/qdeclarativeorganizermodel.cpp
+++ b/plugins/declarative/organizer/qdeclarativeorganizermodel.cpp
@@ -344,16 +344,14 @@ void QDeclarativeOrganizerModel::removeItems(const QList<uint>& ids)
     QOrganizerItemRemoveRequest* req = new QOrganizerItemRemoveRequest(this);
     req->setManager(d->m_manager);
 
-    QList<QOrganizerItemLocalId> localIds;
     foreach (uint id, ids) {
         QOrganizerItemId itemId = itemIdFromHash(id);
-        if (!itemId.localId().isNull()) {
-            localIds << itemId.localId();
+        if (!itemId.isNull()) {
              qt_organizerItemIdHash.remove(id);
         }
     }
 
-    req->setItemIds(localIds);
+    req->setItemIds(ids);
 
     connect(req,SIGNAL(stateChanged(QOrganizerAbstractRequest::State)), this, SLOT(itemRemoved()));
 
diff --git a/plugins/organizer/maemo5/qorganizerasynchprocess.cpp b/plugins/organizer/maemo5/qorganizerasynchprocess.cpp
index b3ada604fa..6a493cb1f8 100644
--- a/plugins/organizer/maemo5/qorganizerasynchprocess.cpp
+++ b/plugins/organizer/maemo5/qorganizerasynchprocess.cpp
@@ -230,7 +230,7 @@ void OrganizerAsynchProcess::processRequest()
         handleItemOccurrenceFetchRequest(static_cast<QOrganizerItemOccurrenceFetchRequest *>(req));
         break;
     case QOrganizerAbstractRequest::ItemLocalIdFetchRequest:
-        handleLocalIdFetchRequest(static_cast<QOrganizerItemLocalIdFetchRequest *>(req));
+        handleIdFetchRequest(static_cast<QOrganizerItemIdFetchRequest *>(req));
         break;
     case QOrganizerAbstractRequest::ItemRemoveRequest:
         handleItemRemoveRequest(static_cast<QOrganizerItemRemoveRequest *>(req));
@@ -286,11 +286,11 @@ void OrganizerAsynchProcess::handleItemOccurrenceFetchRequest(QOrganizerItemOccu
     QOrganizerManagerEngine::updateItemOccurrenceFetchRequest(req, items, err, QOrganizerAbstractRequest::FinishedState);
 }
 
-void OrganizerAsynchProcess::handleLocalIdFetchRequest(QOrganizerItemLocalIdFetchRequest *req)
+void OrganizerAsynchProcess::handleIdFetchRequest(QOrganizerItemIdFetchRequest *req)
 {
     QOrganizerManager::Error err = QOrganizerManager::NoError;
-    QList<QOrganizerItemLocalId> ids = m_engine->itemIds(req->startDate(), req->endDate(), req->filter(), req->sorting(), &err);
-    QOrganizerManagerEngine::updateItemLocalIdFetchRequest(req, ids, err, QOrganizerAbstractRequest::FinishedState);
+    QList<QOrganizerItemId> ids = m_engine->itemIds(req->startDate(), req->endDate(), req->filter(), req->sorting(), &err);
+    QOrganizerManagerEngine::updateItemIdFetchRequest(req, ids, err, QOrganizerAbstractRequest::FinishedState);
 }
 
 void OrganizerAsynchProcess::handleItemRemoveRequest(QOrganizerItemRemoveRequest *req)
diff --git a/plugins/organizer/maemo5/qorganizerasynchprocess.h b/plugins/organizer/maemo5/qorganizerasynchprocess.h
index 34ca4a6cb9..1904140d7d 100644
--- a/plugins/organizer/maemo5/qorganizerasynchprocess.h
+++ b/plugins/organizer/maemo5/qorganizerasynchprocess.h
@@ -109,7 +109,7 @@ private:
     void handleItemFetchRequest(QOrganizerItemFetchRequest *req);
     void handleItemFetchForExportRequest(QOrganizerItemFetchForExportRequest *req);
     void handleItemOccurrenceFetchRequest(QOrganizerItemOccurrenceFetchRequest *req);
-    void handleLocalIdFetchRequest(QOrganizerItemLocalIdFetchRequest *req);
+    void handleIdFetchRequest(QOrganizerItemIdFetchRequest *req);
     void handleItemRemoveRequest(QOrganizerItemRemoveRequest *req);
     void handleSaveRequest(QOrganizerItemSaveRequest *req);
     void handleDefinitionFetchRequest(QOrganizerItemDetailDefinitionFetchRequest *req);
diff --git a/plugins/organizer/maemo5/qorganizercaldbaccess.cpp b/plugins/organizer/maemo5/qorganizercaldbaccess.cpp
index 99ac2c431e..47a76ce191 100644
--- a/plugins/organizer/maemo5/qorganizercaldbaccess.cpp
+++ b/plugins/organizer/maemo5/qorganizercaldbaccess.cpp
@@ -119,7 +119,7 @@ void OrganizerCalendarDatabaseAccess::close()
     m_db.close();
 }
 
-int OrganizerCalendarDatabaseAccess::calIdOf(QOrganizerItemLocalId id)
+int OrganizerCalendarDatabaseAccess::calIdOf(QOrganizerItemId id)
 {
     quint32 convertedId = readItemLocalId(id);
     if (m_dbCache->containsCalId(convertedId)) {
@@ -142,7 +142,7 @@ int OrganizerCalendarDatabaseAccess::calIdOf(QOrganizerItemLocalId id)
     }
 }
 
-int OrganizerCalendarDatabaseAccess::typeOf(QOrganizerItemLocalId id)
+int OrganizerCalendarDatabaseAccess::typeOf(QOrganizerItemId id)
 {
     quint32 convertedId = readItemLocalId(id);
     if (m_dbCache->containsTypeId(convertedId)) {
diff --git a/plugins/organizer/maemo5/qorganizercaldbaccess.h b/plugins/organizer/maemo5/qorganizercaldbaccess.h
index c04eefee0e..3e502d9fd4 100644
--- a/plugins/organizer/maemo5/qorganizercaldbaccess.h
+++ b/plugins/organizer/maemo5/qorganizercaldbaccess.h
@@ -73,8 +73,8 @@ public:
     bool open(QString databasePathName);
     void close();
 
-    int calIdOf(QOrganizerItemLocalId id);
-    int typeOf(QOrganizerItemLocalId id);
+    int calIdOf(QOrganizerItemId id);
+    int typeOf(QOrganizerItemId id);
     std::vector<CEvent *> getEvents(int calId, std::string guid, int &pErrorCode);
     std::vector<CTodo *> getTodos(int calId, std::string guid, int &pErrorCode);
     std::vector<CJournal *> getJournals(int calId, std::string guid, int &pErrorCode);
diff --git a/plugins/organizer/maemo5/qorganizeritemtransform.cpp b/plugins/organizer/maemo5/qorganizeritemtransform.cpp
index 451830fd75..32ad713463 100644
--- a/plugins/organizer/maemo5/qorganizeritemtransform.cpp
+++ b/plugins/organizer/maemo5/qorganizeritemtransform.cpp
@@ -288,7 +288,7 @@ QOrganizerEventOccurrence OrganizerItemTransform::convertCEventToQEventOccurrenc
 {
     QDateTime instanceStartDate = QDateTime::fromTime_t(cevent->getDateStart());
     QDateTime instanceEndDate = QDateTime::fromTime_t(cevent->getDateEnd());
-    return convertCEventToQEventOccurrence(cevent, instanceStartDate, instanceEndDate, QOrganizerItemLocalId(0));
+    return convertCEventToQEventOccurrence(cevent, instanceStartDate, instanceEndDate, QOrganizerItemId(0));
 }
 
 QOrganizerEventOccurrence OrganizerItemTransform::convertCEventToQEventOccurrence(CEvent* cevent, const QDateTime& instanceStartDate, const QDateTime &instanceEndDate)
@@ -315,8 +315,7 @@ QOrganizerEventOccurrence OrganizerItemTransform::convertCEventToQEventOccurrenc
 
     // Set parent local id
     QString idString = QString::fromStdString(cevent->getId());
-    QOrganizerItemLocalId localId(new QOrganizerItemMaemo5EngineLocalId(idString.toUInt()));
-    retn.setParentLocalId(localId);
+    retn.setParentId(QOrganizerItemId(new QOrganizerItemMaemo5EngineLocalId(idString.toUInt())));
 
     // Set original event date
     retn.setOriginalDate(instanceStartDate.date());
@@ -324,10 +323,10 @@ QOrganizerEventOccurrence OrganizerItemTransform::convertCEventToQEventOccurrenc
     return retn;
 }
 
-QOrganizerEventOccurrence OrganizerItemTransform::convertCEventToQEventOccurrence(CEvent *cevent, const QDateTime &instanceStartDate, const QDateTime &instanceEndDate, QOrganizerItemLocalId parentLocalId)
+QOrganizerEventOccurrence OrganizerItemTransform::convertCEventToQEventOccurrence(CEvent *cevent, const QDateTime &instanceStartDate, const QDateTime &instanceEndDate, QOrganizerItemId parentId)
 {
     QOrganizerEventOccurrence retn = convertCEventToQEventOccurrence(cevent, instanceStartDate, instanceEndDate);
-    retn.setParentLocalId(parentLocalId);
+    retn.setParentId(parentId);
     return retn;
 }
 
@@ -413,7 +412,7 @@ QOrganizerTodoOccurrence OrganizerItemTransform::convertCTodoToQTodoOccurrence(C
     // Only the following are occurrence specific details:
 
     // In maemo, the parent id is the same as this id (todo's only have one occurrence)
-    retn.setParentLocalId(makeItemLocalId(QString::fromStdString(ctodo->getId()).toUInt()));
+    retn.setParentId(makeItemLocalId(QString::fromStdString(ctodo->getId()).toUInt()));
 
     // Original date
     retn.setOriginalDate(retn.startDateTime().date());
@@ -473,17 +472,12 @@ void OrganizerItemTransform::fillInCommonCComponentDetails(QOrganizerItem *item,
         item->saveDetail(&ig);
 
         // Set component ID
-        QOrganizerItemId id;
-        id.setManagerUri(managerUri());
         if (setId) {
             QString idString = QString::fromStdString(component->getId());
-            QOrganizerItemLocalId localId(new QOrganizerItemMaemo5EngineLocalId(idString.toUInt()));
-            id.setLocalId(localId);
+            item->setId(QOrganizerItemId(new QOrganizerItemMaemo5EngineLocalId(idString.toUInt())));
+        } else {
+            item->setId(QOrganizerItemId());
         }
-        else {
-            id.setLocalId(QOrganizerItemLocalId()); // no local id
-        }
-        item->setId(id);
 
         // Set comments
         CComponentDetails *componentDetails = dynamic_cast<CComponentDetails*>(component);
@@ -533,7 +527,7 @@ CComponent* OrganizerItemTransform::createCComponent(CCalendar *cal, const QOrga
 {
     *error = QOrganizerManager::InvalidItemTypeError;
 
-    QOrganizerItemLocalId itemId = item->localId();
+    QOrganizerItemId itemId = item->id();
 
     QString itemIdStr = "";
     if (!itemId.isNull())
diff --git a/plugins/organizer/maemo5/qorganizeritemtransform.h b/plugins/organizer/maemo5/qorganizeritemtransform.h
index aa4d32f16a..cd38145923 100644
--- a/plugins/organizer/maemo5/qorganizeritemtransform.h
+++ b/plugins/organizer/maemo5/qorganizeritemtransform.h
@@ -78,7 +78,7 @@ public: // transform functions
 
     QOrganizerEventOccurrence convertCEventToQEventOccurrence(CEvent *cevent);
     QOrganizerEventOccurrence convertCEventToQEventOccurrence(CEvent *cevent, const QDateTime &instanceStartDate, const QDateTime &instanceEndDate);
-    QOrganizerEventOccurrence convertCEventToQEventOccurrence(CEvent *cevent, const QDateTime &instanceStartDate, const QDateTime &instanceEndDate, QOrganizerItemLocalId parentLocalId);
+    QOrganizerEventOccurrence convertCEventToQEventOccurrence(CEvent *cevent, const QDateTime &instanceStartDate, const QDateTime &instanceEndDate, QOrganizerItemId parentId);
 
     QOrganizerTodo convertCTodoToQTodo(CTodo *ctodo);
     QOrganizerTodoOccurrence convertCTodoToQTodoOccurrence(CTodo *ctodo);
diff --git a/plugins/organizer/maemo5/qorganizermaemo5.cpp b/plugins/organizer/maemo5/qorganizermaemo5.cpp
index c0d9bca56d..d30ae5b6dc 100644
--- a/plugins/organizer/maemo5/qorganizermaemo5.cpp
+++ b/plugins/organizer/maemo5/qorganizermaemo5.cpp
@@ -114,6 +114,12 @@ uint QOrganizerItemMaemo5EngineLocalId::engineLocalIdType() const
     return qHash(QString(QLatin1String("maemo5")));
 }
 
+QString QOrganizerItemMaemo5EngineLocalId::managerUri() const
+{
+    // TODO: fixme
+    return QString::fromLatin1("QOrganizer:maemo5:");
+}
+
 QOrganizerItemEngineLocalId* QOrganizerItemMaemo5EngineLocalId::clone() const
 {
     QOrganizerItemMaemo5EngineLocalId *myClone = new QOrganizerItemMaemo5EngineLocalId;
@@ -122,7 +128,7 @@ QOrganizerItemEngineLocalId* QOrganizerItemMaemo5EngineLocalId::clone() const
 }
 
 #ifndef QT_NO_DEBUG_STREAM
-QDebug QOrganizerItemMaemo5EngineLocalId::debugStreamOut(QDebug dbg)
+QDebug& QOrganizerItemMaemo5EngineLocalId::debugStreamOut(QDebug& dbg)
 {
     dbg.nospace() << "QOrganizerItemMaemo5EngineLocalId(" << m_localItemId << ")";
     return dbg.maybeSpace();
@@ -312,7 +318,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::itemOccurrences(const QOrganiz
     return internalItemOccurrences(parentItem, periodStart, periodEnd, maxCount, error);
 }
 
-QList<QOrganizerItemLocalId> QOrganizerItemMaemo5Engine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const
+QList<QOrganizerItemId> QOrganizerItemMaemo5Engine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const
 {
     QMutexLocker locker(&m_operationMutex);
     return internalItemIds(startDate, endDate, filter, sortOrders, error);
@@ -330,7 +336,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::itemsForExport(const QDateTime
     return internalItems(startDate, endDate, filter, sortOrders, fetchHint, true, error);
 }
 
-QOrganizerItem QOrganizerItemMaemo5Engine::item(const QOrganizerItemLocalId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const
+QOrganizerItem QOrganizerItemMaemo5Engine::item(const QOrganizerItemId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const
 {
     QMutexLocker locker(&m_operationMutex);
     return internalItem(itemId, fetchHint, error);
@@ -342,7 +348,7 @@ bool QOrganizerItemMaemo5Engine::saveItems(QList<QOrganizerItem>* items, QMap<in
     return internalSaveItems(items, errorMap, error);
 }
 
-bool QOrganizerItemMaemo5Engine::removeItems(const QList<QOrganizerItemLocalId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error)
+bool QOrganizerItemMaemo5Engine::removeItems(const QList<QOrganizerItemId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error)
 {
     QMutexLocker locker(&m_operationMutex);
     return internalRemoveItems(itemIds, errorMap, error);
@@ -420,7 +426,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItemOccurrences(const
         return retn;
     }
 
-    std::string nativeId = QString::number(readItemLocalId(parentItem.localId())).toStdString();
+    std::string nativeId = QString::number(readItemLocalId(parentItem.id())).toStdString();
 
     if (parentItem.type() == QOrganizerItemType::TypeEvent)
     {
@@ -477,7 +483,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItemOccurrences(const
                         QDateTime instanceStartDate = QDateTime::fromTime_t(coccurrenceCandidate->getDateStart());
                         QDateTime instanceEndDate = QDateTime::fromTime_t(coccurrenceCandidate->getDateEnd());
                         QString idString = QString::fromStdString(cevent->getId());
-                        QOrganizerItemLocalId parentLocalId(new QOrganizerItemMaemo5EngineLocalId(idString.toUInt())); // ctor takes ownership of the ptr.
+                        QOrganizerItemId parentId(new QOrganizerItemMaemo5EngineLocalId(idString.toUInt())); // ctor takes ownership of the ptr.
 
                         // instance must be within the period
                         // NOTE: If this implementation have to be changed so that only items
@@ -488,7 +494,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItemOccurrences(const
                             if (isOccurrence(cal, coccurrenceCandidate, eventType, error)) {
                                 if (*error == QOrganizerManager::NoError) {
                                     QOrganizerEventOccurrence eventOcc =
-                                            d->m_itemTransformer.convertCEventToQEventOccurrence(coccurrenceCandidate, instanceStartDate, instanceEndDate, parentLocalId);
+                                            d->m_itemTransformer.convertCEventToQEventOccurrence(coccurrenceCandidate, instanceStartDate, instanceEndDate, parentId);
                                     d->m_itemTransformer.fillInCommonCComponentDetails(&eventOcc, coccurrenceCandidate);
 
                                     // Set the collection id
@@ -545,7 +551,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItemOccurrences(const
     return retn;
 }
 
-QList<QOrganizerItemLocalId> QOrganizerItemMaemo5Engine::internalItemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const
+QList<QOrganizerItemId> QOrganizerItemMaemo5Engine::internalItemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const
 {
     QList<QOrganizerItem> clist = internalItems(startDate, endDate, filter, sortOrders, fetchMinimalData(), true, error);
 
@@ -557,7 +563,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItems(const QDateTime&
 {
     *error = QOrganizerManager::NoError;
     int calError = CALENDAR_OPERATION_SUCCESSFUL;
-    QList<QOrganizerItemLocalId> localIds;
+    QList<QOrganizerItemId> localIds;
 
     // Resolve from which collections (calendars) the items must be fetch (pre-filtering)
     QSet<QOrganizerCollectionId> collectionIds = extractCollectionIds(filter);
@@ -593,7 +599,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItems(const QDateTime&
         if (*error != QOrganizerManager::NoError)
             return QList<QOrganizerItem>();
         for (id = eventIds.begin(); id != eventIds.end(); ++id)
-            localIds << QOrganizerItemLocalId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(*id).toUInt()));
+            localIds << QOrganizerItemId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(*id).toUInt()));
 
         // Append todo ids
         std::vector<std::string> todoIds;
@@ -603,7 +609,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItems(const QDateTime&
         if (*error != QOrganizerManager::NoError)
             return QList<QOrganizerItem>();
         for (id = todoIds.begin(); id != todoIds.end(); ++id)
-            localIds << QOrganizerItemLocalId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(*id).toUInt()));
+            localIds << QOrganizerItemId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(*id).toUInt()));
 
         // Append journal ids
         std::vector<std::string> journalIds;
@@ -613,7 +619,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItems(const QDateTime&
         if (*error != QOrganizerManager::NoError)
             return QList<QOrganizerItem>();
         for (id = journalIds.begin(); id != journalIds.end(); ++id)
-            localIds << QOrganizerItemLocalId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(*id).toUInt()));
+            localIds << QOrganizerItemId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(*id).toUInt()));
 
         // Cleanup calendar
         cleanupCal(cal);
@@ -621,7 +627,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItems(const QDateTime&
 
     // Use the general implementation to filter and sort items
     QList<QOrganizerItem> filteredAndSorted;
-    foreach(const QOrganizerItemLocalId& id, localIds) {
+    foreach(const QOrganizerItemId& id, localIds) {
         QOrganizerItem item = internalFetchItem(id, fetchHint, error, true);
         if (*error == QOrganizerManager::NoError) {
             if (item.type() == QOrganizerItemType::TypeEvent) {
@@ -640,7 +646,7 @@ QList<QOrganizerItem> QOrganizerItemMaemo5Engine::internalItems(const QDateTime&
 void QOrganizerItemMaemo5Engine::internalAddOccurances(QList<QOrganizerItem>* sorted, QOrganizerItem& item, const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, bool forExport, QOrganizerManager::Error *error) const
 {
     CCalendar *cal = d->m_mcInstance->getDefaultCalendar();
-    std::string nativeId = QString::number(readItemLocalId(item.localId())).toStdString();
+    std::string nativeId = QString::number(readItemLocalId(item.id())).toStdString();
     int calError = CALENDAR_OPERATION_SUCCESSFUL;
     CEvent *cevent = d->m_dbAccess->getEvent(cal, nativeId, calError);
     *error = d->m_itemTransformer.calErrorToManagerError(calError);
@@ -689,7 +695,7 @@ void QOrganizerItemMaemo5Engine::internalAddOccurances(QList<QOrganizerItem>* so
     }
 }
 
-QOrganizerItem QOrganizerItemMaemo5Engine::internalItem(const QOrganizerItemLocalId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const
+QOrganizerItem QOrganizerItemMaemo5Engine::internalItem(const QOrganizerItemId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const
 {
     return internalFetchItem(itemId, fetchHint, error, true);
 }
@@ -765,7 +771,7 @@ bool QOrganizerItemMaemo5Engine::internalSaveItems(QList<QOrganizerItem>* items,
     return success;
 }
 
-bool QOrganizerItemMaemo5Engine::internalRemoveItems(const QList<QOrganizerItemLocalId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error)
+bool QOrganizerItemMaemo5Engine::internalRemoveItems(const QList<QOrganizerItemId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error)
 {
     QOrganizerManager::Error tempError = QOrganizerManager::NoError;
     *error = QOrganizerManager::NoError;
@@ -773,15 +779,15 @@ bool QOrganizerItemMaemo5Engine::internalRemoveItems(const QList<QOrganizerItemL
     bool success = true;
     QOrganizerItemChangeSet cs;
 
-    QList<QOrganizerItemLocalId> idsToDelete = itemIds;
+    QList<QOrganizerItemId> idsToDelete = itemIds;
     int i = 0;
     while (i < idsToDelete.size()) {
-        QOrganizerItemLocalId currId = idsToDelete.at(i);
+        QOrganizerItemId currId = idsToDelete.at(i);
 
         QOrganizerItem currItem = internalFetchItem(currId, fetchMinimalData(), &tempError, false);
         if (tempError == QOrganizerManager::NoError) {
             // Item exists
-            QString itemId = QString::number(readItemLocalId(currItem.localId()));
+            QString itemId = QString::number(readItemLocalId(currItem.id()));
             int calError = CALENDAR_OPERATION_SUCCESSFUL;
             if (currItem.type() == QOrganizerItemType::TypeEvent) {
                 // Delete also child events if this event is a parent
@@ -794,7 +800,7 @@ bool QOrganizerItemMaemo5Engine::internalRemoveItems(const QList<QOrganizerItemL
                         if (calError == CALENDAR_OPERATION_SUCCESSFUL) {
                             std::vector<CEvent*>::const_iterator childEvent;
                             for (childEvent = eventsWithGuid.begin(); childEvent != eventsWithGuid.end(); ++childEvent) {
-                                QOrganizerItemLocalId childId = makeItemLocalId(QString::fromStdString((*childEvent)->getId()).toUInt());
+                                QOrganizerItemId childId = makeItemLocalId(QString::fromStdString((*childEvent)->getId()).toUInt());
                                 if (!idsToDelete.contains(childId))
                                     idsToDelete << childId;
                                 delete *childEvent;
@@ -814,7 +820,7 @@ bool QOrganizerItemMaemo5Engine::internalRemoveItems(const QList<QOrganizerItemL
 
                 if (calError == CALENDAR_OPERATION_SUCCESSFUL) {
                     // Success, update the changeset
-                    cs.insertRemovedItem(currItem.localId());
+                    cs.insertRemovedItem(currItem.id());
                 }
                 else {
                     success = false;
@@ -1175,8 +1181,8 @@ void QOrganizerItemMaemo5Engine::checkItemIdValidity(QOrganizerItem *checkItem,
 {
     *error = QOrganizerManager::NoError;
 
-    // Check local id
-    if (!checkItem->localId().isNull()) {
+    // Check id
+    if (!checkItem->id().isNull()) {
         // Don't allow saving with local id defined unless the item is from this manager.
         if (checkItem->id().managerUri() != managerUri()) {
             *error = QOrganizerManager::BadArgumentError;
@@ -1207,15 +1213,15 @@ void QOrganizerItemMaemo5Engine::checkItemIdValidity(QOrganizerItem *checkItem,
         }
 
         // Either parent id or GUID (or both) must be set
-        if (eventOccurrence->parentLocalId().isNull() && eventOccurrence->guid().isEmpty()) {
+        if (eventOccurrence->parentId().isNull() && eventOccurrence->guid().isEmpty()) {
             *error = QOrganizerManager::InvalidOccurrenceError;
             return;
         }
 
         // If the parent ID is set, it must point to an event
         QOrganizerItem parent;
-        if (!eventOccurrence->parentLocalId().isNull()) {
-            parent = internalItem(eventOccurrence->parentLocalId(), fetchMinimalData(), error);
+        if (!eventOccurrence->parentId().isNull()) {
+            parent = internalItem(eventOccurrence->parentId(), fetchMinimalData(), error);
             if (*error != QOrganizerManager::NoError)
                 return;
 
@@ -1250,7 +1256,7 @@ void QOrganizerItemMaemo5Engine::checkItemIdValidity(QOrganizerItem *checkItem,
         }
 
         // If both parent ID and GUID are set, they must be consistent
-        if (!eventOccurrence->parentLocalId().isNull() && !eventOccurrence->guid().isEmpty()) {
+        if (!eventOccurrence->parentId().isNull() && !eventOccurrence->guid().isEmpty()) {
             if (eventOccurrence->guid() != parent.guid()) {
                 *error = QOrganizerManager::InvalidOccurrenceError;
                 return;
@@ -1267,14 +1273,14 @@ void QOrganizerItemMaemo5Engine::checkItemIdValidity(QOrganizerItem *checkItem,
         }
 
         // Either parent id or GUID (or both) must be set
-        if (todoOccurrence->parentLocalId().isNull() && todoOccurrence->guid().isEmpty()) {
+        if (todoOccurrence->parentId().isNull() && todoOccurrence->guid().isEmpty()) {
             *error = QOrganizerManager::InvalidOccurrenceError;
             return;
         }
 
-        if (!todoOccurrence->parentLocalId().isNull()) {
+        if (!todoOccurrence->parentId().isNull()) {
             // Parent ID must point to this occurrence due to restrictions in Maemo5 todos
-            if (todoOccurrence->parentLocalId() != todoOccurrence->localId()) {
+            if (todoOccurrence->parentId() != todoOccurrence->id()) {
                 *error = QOrganizerManager::InvalidOccurrenceError;
                 return;
             }
@@ -1373,7 +1379,7 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
                 QPair<qint32, qint32> cookieChange = d->m_itemTransformer.modifyAlarmEvent(cal, item, component);
                 d->m_dbAccess->fixAlarmCookie(cookieChange);
 
-                cs.insertChangedItem(item->localId());
+                cs.insertChangedItem(item->id());
             }
         }
         else {
@@ -1394,11 +1400,8 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
             {
                 // Set id for the event
                 QString newIdString = QString::fromStdString(cevent->getId());
-                QOrganizerItemLocalId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
-                QOrganizerItemId id;
-                id.setLocalId(newId);
-                id.setManagerUri(managerUri());
-                item->setId(id);
+                QOrganizerItemId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
+                item->setId(newId);
 
                 // Modify alarm to contain the reminder information
                 // (must always be done only after the component is saved)
@@ -1407,9 +1410,9 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
 
                 // Update changeset
                 if (calError == CALENDAR_ENTRY_DUPLICATED)
-                    cs.insertChangedItem(item->localId());
+                    cs.insertChangedItem(item->id());
                 else
-                    cs.insertAddedItem(item->localId());
+                    cs.insertAddedItem(item->id());
 
                 calError = CALENDAR_OPERATION_SUCCESSFUL; // reset the error
                 *error = QOrganizerManager::NoError; // reset the error
@@ -1424,7 +1427,7 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
     }
     else if (item->type() == QOrganizerItemType::TypeEventOccurrence)
     {
-        if (!eventOccurrenceParent.localId().isNull()) {
+        if (!eventOccurrenceParent.id().isNull()) {
             QOrganizerEventOccurrence *eventOccurrence = static_cast<QOrganizerEventOccurrence *>(item);
             QOrganizerEvent *parentEvent = static_cast<QOrganizerEvent *>(&eventOccurrenceParent);
 
@@ -1479,7 +1482,7 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
                 QPair<qint32, qint32> cookieChange = d->m_itemTransformer.modifyAlarmEvent(cal, item, component);
                 d->m_dbAccess->fixAlarmCookie(cookieChange);
 
-                cs.insertChangedItem(item->localId());
+                cs.insertChangedItem(item->id());
             }
         }
         else {
@@ -1500,11 +1503,8 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
             {
                 // Set id for the todo
                 QString newIdString = QString::fromStdString(ctodo->getId());
-                QOrganizerItemLocalId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
-                QOrganizerItemId id;
-                id.setLocalId(newId);
-                id.setManagerUri(managerUri());
-                item->setId(id);
+                QOrganizerItemId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
+                item->setId(newId);
 
                 // Modify alarm to contain the reminder information
                 // (must always be done only after the component is saved)
@@ -1513,9 +1513,9 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
 
                 // Update changeset
                 if (calError == CALENDAR_ENTRY_DUPLICATED)
-                    cs.insertChangedItem(item->localId());
+                    cs.insertChangedItem(item->id());
                 else
-                    cs.insertAddedItem(item->localId());
+                    cs.insertAddedItem(item->id());
 
                 calError = CALENDAR_OPERATION_SUCCESSFUL; // reset the error
                 *error = QOrganizerManager::NoError; // reset the error
@@ -1545,7 +1545,7 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
                 QPair<qint32, qint32> cookieChange = d->m_itemTransformer.modifyAlarmEvent(cal, item, component);
                 d->m_dbAccess->fixAlarmCookie(cookieChange);
 
-                cs.insertChangedItem(item->localId());
+                cs.insertChangedItem(item->id());
             }
         }
         else {
@@ -1566,11 +1566,8 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
             {
                 // Set id for the journal
                 QString newIdString = QString::fromStdString(cjournal->getId());
-                QOrganizerItemLocalId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
-                QOrganizerItemId id;
-                id.setLocalId(newId);
-                id.setManagerUri(managerUri());
-                item->setId(id);
+                QOrganizerItemId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
+                item->setId(newId);
 
                 // Modify alarm to contain the reminder information
                 // (must always be done only after the component is saved)
@@ -1579,9 +1576,9 @@ int QOrganizerItemMaemo5Engine::doSaveItem(CCalendar *cal, QOrganizerItem *item,
 
                 // Update changeset
                 if (calError == CALENDAR_ENTRY_DUPLICATED)
-                    cs.insertChangedItem(item->localId());
+                    cs.insertChangedItem(item->id());
                 else
-                    cs.insertAddedItem(item->localId());
+                    cs.insertAddedItem(item->id());
 
                 calError = CALENDAR_OPERATION_SUCCESSFUL; // reset the error
                 *error = QOrganizerManager::NoError; // reset the error
@@ -1605,7 +1602,7 @@ int QOrganizerItemMaemo5Engine::saveEventOccurrence(CCalendar *cal, QOrganizerEv
     occurrence->setGuid(parent->guid());
 
     // set occurrence's parent id
-    occurrence->setParentLocalId(parent->localId());
+    occurrence->setParentId(parent->id());
 
     // backup the parent item
     QOrganizerEvent parentBackup(*parent);
@@ -1613,7 +1610,7 @@ int QOrganizerItemMaemo5Engine::saveEventOccurrence(CCalendar *cal, QOrganizerEv
     // did parent become modified
     bool parentModified = false;
 
-    if (occurrence->localId().isNull()) {
+    if (occurrence->id().isNull()) {
         // Does not contain a local id => this is a generated occurrence or a new exception occurrence
         // After modifications this won't be saved anymore as a generated occurrence
         // but as an event to the calendar DB. Add an exception rule to the parent item
@@ -1738,17 +1735,14 @@ int QOrganizerItemMaemo5Engine::saveEventOccurrence(CCalendar *cal, QOrganizerEv
 
             // Set id for the occurrence
             QString newIdString = QString::fromStdString(cevent->getId());
-            QOrganizerItemLocalId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
-            QOrganizerItemId id;
-            id.setLocalId(newId);
-            id.setManagerUri(managerUri());
-            occurrence->setId(id);
+            QOrganizerItemId newId(new QOrganizerItemMaemo5EngineLocalId(newIdString.toUInt()));
+            occurrence->setId(newId);
 
             // Update changeset
             if (calError == CALENDAR_ENTRY_DUPLICATED)
-                cs.insertChangedItem(occurrence->localId());
+                cs.insertChangedItem(occurrence->id());
             else
-                cs.insertAddedItem(occurrence->localId());
+                cs.insertAddedItem(occurrence->id());
 
             calError = CALENDAR_OPERATION_SUCCESSFUL; // reset the error
             *error = QOrganizerManager::NoError; // reset the error
@@ -1787,12 +1781,12 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
     // The occurrence is supposed be valid when this method becomes called.
     // If cal parameter is set to null and the parent local id is not provided,
     // the parent will be searched from all the calendars.
-    QOrganizerItemLocalId parentLocalId;
+    QOrganizerItemId parentId;
     if (occurrence->type() == QOrganizerItemType::TypeEventOccurrence) {
         QOrganizerEventOccurrence *eventOccurrence = static_cast<QOrganizerEventOccurrence *>(occurrence);
-        if (!eventOccurrence->parentLocalId().isNull()) {
+        if (!eventOccurrence->parentId().isNull()) {
             // the simple case: the parent local id was set
-            parentLocalId = eventOccurrence->parentLocalId();
+            parentId = eventOccurrence->parentId();
         }
         else {
             // parent local id was not set, fetch with [GUID,originalDate]
@@ -1821,7 +1815,7 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
             // Check if some event contains recurrence information and then that the given
             // occurrence is one of the occurrences obtained from the recurrence information.
             for (pCand = parentCands.begin(); pCand != parentCands.end(); ++pCand) {
-                QOrganizerItemLocalId candidateLocalId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString((*pCand)->getId()).toUInt()));
+                QOrganizerItemId candidateLocalId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString((*pCand)->getId()).toUInt()));
 
                 QOrganizerItem parentCandidate = internalFetchItem(candidateLocalId, fetchMinimalData(), error, false);
                 if (*error == QOrganizerManager::NoError) {
@@ -1834,7 +1828,7 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
                         if (eventOccurrence->originalDate() == QDate()) {
                             // The given occurrence is a new one, not previously saved in the DB.
                             // If there is an event with recurrence information, it must be the parent.
-                            parentLocalId = candidateLocalId;
+                            parentId = candidateLocalId;
                             break; // parent event found
                         }
                         else {
@@ -1851,7 +1845,7 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
 
                             // Because the period was set, it's enough to just check if we got any
                             if (!parentCandidateOccurrences.isEmpty()) {
-                                parentLocalId = candidateLocalId;
+                                parentId = candidateLocalId;
                                 break; // parent event found
                             }
                         }
@@ -1864,7 +1858,7 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
                 }
             }
 
-            if (!parentLocalId.isNull())
+            if (!parentId.isNull())
             {
                 // Parent local id got, just free the resources
                 for (pCand = parentCands.begin(); pCand != parentCands.end(); ++pCand)
@@ -1890,8 +1884,8 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
 
                 if (firstCreated) {
                     // the firstly created event resolved, return it as parent
-		    QOrganizerItemLocalId resolvedParentId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(firstCreated->getId()).toUInt()));
-                    parentLocalId = resolvedParentId; // assignment operator will automatically delete the d if it exists, therefore avoids leaking memory.
+            QOrganizerItemId resolvedParentId(new QOrganizerItemMaemo5EngineLocalId(QString::fromStdString(firstCreated->getId()).toUInt()));
+                    parentId = resolvedParentId; // assignment operator will automatically delete the d if it exists, therefore avoids leaking memory.
                 }
 
                 // Free the resources
@@ -1902,17 +1896,17 @@ QOrganizerItem QOrganizerItemMaemo5Engine::parentOf(CCalendar *cal, QOrganizerIt
     }
     else if (occurrence->type() == QOrganizerItemType::TypeTodoOccurrence) {
         // In Maemo5 parent of a todo occurrence is the occurrence itself
-        parentLocalId = occurrence->localId();
+        parentId = occurrence->id();
     }
     else {
         return QOrganizerItem(); // other types can't have a parent
     }
 
     // Parent local id got, now fetch & return the parent
-    return internalFetchItem(parentLocalId, fetchMinimalData(), error, false);
+    return internalFetchItem(parentId, fetchMinimalData(), error, false);
 }
 
-QOrganizerItem QOrganizerItemMaemo5Engine::internalFetchItem(const QOrganizerItemLocalId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error, bool fetchOccurrences) const
+QOrganizerItem QOrganizerItemMaemo5Engine::internalFetchItem(const QOrganizerItemId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error, bool fetchOccurrences) const
 {
     Q_UNUSED(fetchHint); // there are never large binary blobs etc. attached to maemo5 calendar items
 
@@ -1982,7 +1976,7 @@ QOrganizerItem QOrganizerItemMaemo5Engine::internalFetchItem(const QOrganizerIte
                 cleanupCal(cal);
                 return QOrganizerItem();
             }
-            retn.setParentLocalId(parent.localId());
+            retn.setParentId(parent.id());
 
             delete cevent;
             cleanupCal(cal);
diff --git a/plugins/organizer/maemo5/qorganizermaemo5_p.h b/plugins/organizer/maemo5/qorganizermaemo5_p.h
index b37f5dd4cd..3fd7c9a89c 100644
--- a/plugins/organizer/maemo5/qorganizermaemo5_p.h
+++ b/plugins/organizer/maemo5/qorganizermaemo5_p.h
@@ -151,14 +151,14 @@ public:
     int managerVersion() const;
 
     QList<QOrganizerItem> itemOccurrences(const QOrganizerItem& parentItem, const QDateTime& periodStart, const QDateTime& periodEnd, int maxCount, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
-    QList<QOrganizerItemLocalId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const;
+    QList<QOrganizerItemId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const;
 
     QList<QOrganizerItem> items(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const;
     QList<QOrganizerItem> itemsForExport(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const;
-    QOrganizerItem item(const QOrganizerItemLocalId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const;
+    QOrganizerItem item(const QOrganizerItemId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const;
 
     bool saveItems(QList<QOrganizerItem>* items, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
-    bool removeItems(const QList<QOrganizerItemLocalId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error);
+    bool removeItems(const QList<QOrganizerItemId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error);
 
     /* Collections - every item belongs to exactly one collection */
     QOrganizerCollection defaultCollection(QOrganizerManager::Error* error) const;
@@ -187,14 +187,14 @@ public Q_SLOTS:
 
 private:
     QList<QOrganizerItem> internalItemOccurrences(const QOrganizerItem &parentItem, const QDateTime &periodStart, const QDateTime &periodEnd, int maxCount, QOrganizerManager::Error *error) const;
-    QList<QOrganizerItemLocalId> internalItemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const;
+    QList<QOrganizerItemId> internalItemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, QOrganizerManager::Error *error) const;
 
     QList<QOrganizerItem> internalItems(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, const QOrganizerItemFetchHint &fetchHint, bool forExport, QOrganizerManager::Error *error) const;
     void internalAddOccurances(QList<QOrganizerItem>* sorted, QOrganizerItem& item, const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter &filter, const QList<QOrganizerItemSortOrder> &sortOrders, bool forExport, QOrganizerManager::Error *error) const;
-    QOrganizerItem internalItem(const QOrganizerItemLocalId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const;
+    QOrganizerItem internalItem(const QOrganizerItemId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error) const;
 
     bool internalSaveItems(QList<QOrganizerItem>* items, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
-    bool internalRemoveItems(const QList<QOrganizerItemLocalId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error);
+    bool internalRemoveItems(const QList<QOrganizerItemId> &itemIds, QMap<int, QOrganizerManager::Error> *errorMap, QOrganizerManager::Error *error);
 
     /* Collections - every item belongs to exactly one collection */
     QOrganizerCollection internalDefaultCollection(QOrganizerManager::Error* error) const;
@@ -217,7 +217,7 @@ private:
     QOrganizerItem parentOf(CCalendar *cal, QOrganizerItem *occurence, QOrganizerManager::Error *error) const;
 
     // internal fetch item
-    QOrganizerItem internalFetchItem(const QOrganizerItemLocalId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error, bool fetchOccurrences) const;
+    QOrganizerItem internalFetchItem(const QOrganizerItemId &itemId, const QOrganizerItemFetchHint &fetchHint, QOrganizerManager::Error *error, bool fetchOccurrences) const;
 
     // identifying native item as an occurrence
     bool isOccurrence(CCalendar *cal, CComponent *ccomponent, QString typeStr, QOrganizerManager::Error *error) const;
diff --git a/plugins/organizer/maemo5/qorganizermaemo5ids_p.h b/plugins/organizer/maemo5/qorganizermaemo5ids_p.h
index 891ead4048..aac6a986fa 100644
--- a/plugins/organizer/maemo5/qorganizermaemo5ids_p.h
+++ b/plugins/organizer/maemo5/qorganizermaemo5ids_p.h
@@ -93,10 +93,11 @@ public:
     bool isLessThan(const QOrganizerItemEngineLocalId* other) const;
 
     uint engineLocalIdType() const;
+    QString managerUri() const;
     QOrganizerItemEngineLocalId* clone() const;
 
 #ifndef QT_NO_DEBUG_STREAM
-    QDebug debugStreamOut(QDebug dbg);
+    QDebug& debugStreamOut(QDebug& dbg);
 #endif
 #ifndef QT_NO_DATASTREAM
     QDataStream& dataStreamOut(QDataStream& out);
@@ -109,11 +110,11 @@ public:
     friend class OrganizerAsynchProcess;
 };
 
-inline QOrganizerItemLocalId makeItemLocalId(quint32 id) {
-    return QOrganizerItemLocalId(new QOrganizerItemMaemo5EngineLocalId(id));
+inline QOrganizerItemId makeItemLocalId(quint32 id) {
+    return QOrganizerItemId(new QOrganizerItemMaemo5EngineLocalId(id));
 }
 
-inline quint32 readItemLocalId(const QOrganizerItemLocalId& id) {
+inline quint32 readItemLocalId(const QOrganizerItemId& id) {
     return static_cast<QOrganizerItemMaemo5EngineLocalId*>(
             QOrganizerManagerEngine::engineLocalItemId(id))->m_localItemId;
 }
diff --git a/plugins/organizer/maemo5/tsrc/tst_maemo5om/tst_maemo5om.cpp b/plugins/organizer/maemo5/tsrc/tst_maemo5om/tst_maemo5om.cpp
index 306b329212..0587813356 100644
--- a/plugins/organizer/maemo5/tsrc/tst_maemo5om/tst_maemo5om.cpp
+++ b/plugins/organizer/maemo5/tsrc/tst_maemo5om/tst_maemo5om.cpp
@@ -133,7 +133,7 @@ void tst_Maemo5Om::addSimpleItem()
     // Save
     QVERIFY(m_om->saveItem(&event1));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event1.id().localId().isNull());
+    QVERIFY(!event1.id().isNull());
     QVERIFY(event1.id().managerUri().contains(managerName));
     QVERIFY(!event1.guid().isEmpty());
 
@@ -150,7 +150,7 @@ void tst_Maemo5Om::addSimpleItem()
     QVERIFY(m_om->saveItems(&items));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
     foreach (QOrganizerItem item, items) {
-        QVERIFY(!item.id().localId().isNull());
+        QVERIFY(!item.id().isNull());
         QVERIFY(item.id().managerUri().contains(managerName));
         QVERIFY(!item.guid().isEmpty());
     }
@@ -169,7 +169,7 @@ void tst_Maemo5Om::addSimpleItem()
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
     QVERIFY(m_om->errorMap().count() == 0);
     foreach ( QOrganizerItem item2, items ) {
-        QVERIFY(!item2.id().localId().isNull());
+        QVERIFY(!item2.id().isNull());
         QVERIFY(item2.id().managerUri().contains(managerName));
         QVERIFY(!item2.guid().isEmpty());
     }
@@ -192,16 +192,16 @@ void tst_Maemo5Om::removeSimpleItem()
     // Save
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
     QVERIFY(!event.guid().isEmpty());
 
     // Remove
-    QVERIFY(m_om->removeItem(event.id().localId()));
+    QVERIFY(m_om->removeItem(event.id()));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
 
     // Try to fetch back, should fail
-    QOrganizerItem fetchItem = m_om->item(event.id().localId());
+    QOrganizerItem fetchItem = m_om->item(event.id());
     QVERIFY(fetchItem == QOrganizerItem());
 
     // Remove list
@@ -213,9 +213,9 @@ void tst_Maemo5Om::removeSimpleItem()
     item3.setDueDateTime( todoDueDateTime3 );
     QVERIFY(m_om->saveItem(&item2));
     QVERIFY(m_om->saveItem(&item3));
-    QList<QOrganizerItemLocalId> itemIds;
-    itemIds.append(item2.localId());
-    itemIds.append(item3.localId());
+    QList<QOrganizerItemId> itemIds;
+    itemIds.append(item2.id());
+    itemIds.append(item3.id());
     QVERIFY(m_om->removeItems(itemIds));
     QVERIFY(m_om->errorMap().count() == 0);
 }
@@ -240,12 +240,12 @@ void tst_Maemo5Om::addEvent() {
     // Save event
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
 
     // Fetch back event
     QOrganizerEvent fetchEvent;
-    QOrganizerItemLocalId fetchId = event.id().localId();
+    QOrganizerItemId fetchId = event.id();
     fetchEvent = static_cast<QOrganizerEvent>(m_om->item(fetchId));
 
     QCOMPARE(fetchEvent.id(), event.id());
@@ -280,12 +280,12 @@ void tst_Maemo5Om::addTodo() {
     // Save todo
     QVERIFY(m_om->saveItem(&todo));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!todo.id().localId().isNull());
+    QVERIFY(!todo.id().isNull());
     QVERIFY(todo.id().managerUri().contains(managerName));
 
     // Fetch back todo
     QOrganizerTodo fetchTodo;
-    QOrganizerItemLocalId fetchId = todo.id().localId();
+    QOrganizerItemId fetchId = todo.id();
     fetchTodo = static_cast<QOrganizerTodo>(m_om->item(fetchId));
     QCOMPARE(fetchTodo.id(), todo.id());
     QCOMPARE(fetchTodo.dueDateTime(), todo.dueDateTime());
@@ -310,12 +310,12 @@ void tst_Maemo5Om::addJournal() {
     // Save journal
     QVERIFY(m_om->saveItem(&journal));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!journal.id().localId().isNull());
+    QVERIFY(!journal.id().isNull());
     QVERIFY(journal.id().managerUri().contains(managerName));
 
     // Fetch back journal
     QOrganizerJournal fetchJournal;
-    QOrganizerItemLocalId fetchId = journal.id().localId();
+    QOrganizerItemId fetchId = journal.id();
     fetchJournal = static_cast<QOrganizerJournal>(m_om->item(fetchId));
     QCOMPARE(fetchJournal.id(), journal.id());
     QCOMPARE(fetchJournal.dateTime(), journal.dateTime());
@@ -348,7 +348,7 @@ void tst_Maemo5Om::addEventWithRecurrence()
     // Save event
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
     QVERIFY(!event.guid().isEmpty());
 
@@ -357,14 +357,14 @@ void tst_Maemo5Om::addEventWithRecurrence()
     QVERIFY(instances.count() == 10);
     foreach(QOrganizerItem instance, instances) {
         QVERIFY(instance.guid() == event.guid());
-        QVERIFY(instance.id().localId().isNull());
+        QVERIFY(instance.id().isNull());
         QVERIFY(instance.id().managerUri().contains(managerName));
         QVERIFY(instance.displayLabel() == event.displayLabel());
         QVERIFY(instance.description() == event.description());
         QVERIFY(instance.type() == QOrganizerItemType::TypeEventOccurrence);
         if (instance.type() == QOrganizerItemType::TypeEventOccurrence) {
             QOrganizerEventOccurrence occ = static_cast<QOrganizerEventOccurrence>(instance);
-            QVERIFY(occ.parentLocalId() == event.id().localId());
+            QVERIFY(occ.parentId() == event.id());
         }
     }
 }
@@ -380,8 +380,8 @@ void tst_Maemo5Om::addEventExceptions()
     rrule.setLimit(3);
     event.setRecurrenceRules(QSet<QOrganizerRecurrenceRule>() << rrule);
     QVERIFY(m_om->saveItem(&event));
-    QVERIFY(!event.localId().isNull());
-    event = m_om->item(event.localId());
+    QVERIFY(!event.id().isNull());
+    event = m_om->item(event.id());
     // the guid must be set so when it is exported to iCalendar, the relationship can be represented
     QVERIFY(!event.guid().isEmpty());
 
@@ -393,16 +393,16 @@ void tst_Maemo5Om::addEventExceptions()
     QCOMPARE(secondItem.type(), QLatin1String(QOrganizerItemType::TypeEventOccurrence));
     QOrganizerEventOccurrence secondEvent = static_cast<QOrganizerEventOccurrence>(secondItem);
     QCOMPARE(secondEvent.startDateTime(), QDateTime(QDate(2010, 1, 8), QTime(11, 0, 0)));
-    QCOMPARE(secondEvent.localId(), QOrganizerItemLocalId());
-    QCOMPARE(secondEvent.parentLocalId(), event.localId());
+    QCOMPARE(secondEvent.id(), QOrganizerItemId());
+    QCOMPARE(secondEvent.parentId(), event.id());
     // save a change to an occurrence's detail (ie. create an exception)
     secondEvent.setDisplayLabel(QLatin1String("seminar"));
     QVERIFY(m_om->saveItem(&secondEvent));
 
     // save a change to an occurrence's time
     QOrganizerEventOccurrence thirdEvent = static_cast<QOrganizerEventOccurrence>(items.at(2));
-    QCOMPARE(thirdEvent.localId(), QOrganizerItemLocalId());
-    QCOMPARE(thirdEvent.parentLocalId(), event.localId());
+    QCOMPARE(thirdEvent.id(), QOrganizerItemId());
+    QCOMPARE(thirdEvent.parentId(), event.id());
     thirdEvent.setStartDateTime(QDateTime(QDate(2010, 1, 15), QTime(10, 0, 0)));
     QVERIFY(m_om->saveItem(&thirdEvent));
 
@@ -416,11 +416,11 @@ void tst_Maemo5Om::addEventExceptions()
     secondItem = items.at(1);
     // the exception's changes have been persisted
     QCOMPARE(secondItem.displayLabel(), QLatin1String("seminar"));
-    QVERIFY(!secondItem.localId().isNull());
+    QVERIFY(!secondItem.id().isNull());
 
     thirdEvent = static_cast<QOrganizerEventOccurrence>(items.at(2));
     QCOMPARE(thirdEvent.startDateTime(), QDateTime(QDate(2010, 1, 15), QTime(10, 0, 0)));
-    QVERIFY(!secondEvent.localId().isNull());
+    QVERIFY(!secondEvent.id().isNull());
 }
 
 void tst_Maemo5Om::addEventExceptionWithGuid()
@@ -439,7 +439,7 @@ void tst_Maemo5Om::addEventExceptionWithGuid()
     christmas.setRecurrenceRules(QSet<QOrganizerRecurrenceRule>() << rrule);
     QVERIFY(m_om->saveItem(&christmas));
     QVERIFY(!christmas.id().managerUri().isEmpty());
-    QVERIFY(!christmas.id().localId().isNull());
+    QVERIFY(!christmas.id().isNull());
 
     QOrganizerEvent newYearsDay;
     newYearsDay.setGuid("newyear");
@@ -476,15 +476,15 @@ void tst_Maemo5Om::addEventExceptionWithGuid()
     exception.setId(QOrganizerItemId());
     exception.setGuid(QLatin1String("christmas"));
     QVERIFY(m_om->saveItem(&exception));
-    QVERIFY(!exception.localId().isNull());
-    QOrganizerEventOccurrence savedException = m_om->item(exception.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId()); // parentLocalId should be set by manager
+    QVERIFY(!exception.id().isNull());
+    QOrganizerEventOccurrence savedException = m_om->item(exception.id());
+    QCOMPARE(savedException.parentId(), christmas.id()); // parentLocalId should be set by manager
 
-    // with the localId, guid and the parentId all set and consistent, it should work
+    // with the id, guid and the parentId all set and consistent, it should work
     exception = savedException;
     QVERIFY(m_om->saveItem(&exception));
-    savedException = m_om->item(exception.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId());
+    savedException = m_om->item(exception.id());
+    QCOMPARE(savedException.parentId(), christmas.id());
 
     // Make a fresh exception object on a fresh date to avoid clashing with the previously saved one
     // can't set parentId to a non-event
@@ -494,18 +494,18 @@ void tst_Maemo5Om::addEventExceptionWithGuid()
     exception2.setEndDateTime(QDateTime(QDate(2011, 12, 26), QTime(0, 0, 0)));
     exception2.setDisplayLabel(QLatin1String("Christmas"));
     exception2.addComment(QLatin1String("With the in-laws"));
-    exception2.setParentLocalId(report.localId()); // report is not an event
+    exception2.setParentId(report.id()); // report is not an event
     QVERIFY(!m_om->saveItem(&exception2));
     QCOMPARE(m_om->error(), QOrganizerManager::InvalidOccurrenceError);
 
     // can't set guid to a non-event
     exception2.setGuid(QLatin1String("report"));
-    exception2.setParentLocalId(QOrganizerItemLocalId());
+    exception2.setParentId(QOrganizerItemId());
     QVERIFY(!m_om->saveItem(&exception2));
     QCOMPARE(m_om->error(), QOrganizerManager::InvalidOccurrenceError);
 
     // can't make the guid inconsistent with the parentId
-    exception2.setParentLocalId(christmas.localId());
+    exception2.setParentId(christmas.id());
     exception2.setGuid(QLatin1String("newyear"));
     QVERIFY(!m_om->saveItem(&exception2));
     QCOMPARE(m_om->error(), QOrganizerManager::InvalidOccurrenceError);
@@ -513,8 +513,8 @@ void tst_Maemo5Om::addEventExceptionWithGuid()
     // with just the parentId set to a valid parent, it should work
     exception2.setGuid(QLatin1String(""));
     QVERIFY(m_om->saveItem(&exception2));
-    savedException = m_om->item(exception2.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId());
+    savedException = m_om->item(exception2.id());
+    QCOMPARE(savedException.parentId(), christmas.id());
     QCOMPARE(savedException.guid(), QLatin1String("christmas")); // guid should be set by manager
 
     // Make a fresh exception object on a fresh date to avoid clashing with the previously saved one
@@ -524,17 +524,17 @@ void tst_Maemo5Om::addEventExceptionWithGuid()
     exception3.setEndDateTime(QDateTime(QDate(2012, 12, 26), QTime(0, 0, 0)));
     exception3.setDisplayLabel(QLatin1String("Christmas"));
     exception3.addComment(QLatin1String("With the in-laws"));
-    exception3.setParentLocalId(christmas.localId());
+    exception3.setParentId(christmas.id());
     exception3.setGuid(QLatin1String("christmas"));
     QVERIFY(!m_om->saveItem(&exception3));
     QCOMPARE(m_om->error(), QOrganizerManager::InvalidOccurrenceError);
 
-    // with original date, guid and parentId set and consistent, and localId=0, it should work
+    // with original date, guid and parentId set and consistent, and id=0, it should work
     exception3.setOriginalDate(QDate(2012, 12, 25));
     QVERIFY(m_om->saveItem(&exception3));
-    QVERIFY(!exception3.localId().isNull());
-    savedException = m_om->item(exception3.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId());
+    QVERIFY(!exception3.id().isNull());
+    savedException = m_om->item(exception3.id());
+    QCOMPARE(savedException.parentId(), christmas.id());
 }
 
 void tst_Maemo5Om::removeEventWithRecurrence()
@@ -561,7 +561,7 @@ void tst_Maemo5Om::removeEventWithRecurrence()
     // Save event
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
     QVERIFY(!event.guid().isEmpty());
 
@@ -570,19 +570,19 @@ void tst_Maemo5Om::removeEventWithRecurrence()
     QVERIFY(instances.count() == 20);
     foreach(QOrganizerItem instance, instances) {
         QVERIFY(instance.guid() == event.guid());
-        QVERIFY(instance.id().localId().isNull());
+        QVERIFY(instance.id().isNull());
         QVERIFY(instance.id().managerUri().contains(managerName));
         QVERIFY(instance.displayLabel() == event.displayLabel());
         QVERIFY(instance.description() == event.description());
         QVERIFY(instance.type() == QOrganizerItemType::TypeEventOccurrence);
         if (instance.type() == QOrganizerItemType::TypeEventOccurrence) {
             QOrganizerEventOccurrence occ = static_cast<QOrganizerEventOccurrence>(instance);
-            QVERIFY(occ.parentLocalId() == event.id().localId());
+            QVERIFY(occ.parentId() == event.id());
         }
     }
 
     // Remove event
-    QVERIFY(m_om->removeItem(event.id().localId()));
+    QVERIFY(m_om->removeItem(event.id()));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
 
     // Fetch all event instances
@@ -616,7 +616,7 @@ void tst_Maemo5Om::removeEventExceptions()
     // Save event
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
     QVERIFY(!event.guid().isEmpty());
 
@@ -660,7 +660,7 @@ void tst_Maemo5Om::removeEventExceptions()
         QCOMPARE(instances.count(), 11);
 
         // Delete event
-        QVERIFY(m_om->removeItem(event.id().localId()));
+        QVERIFY(m_om->removeItem(event.id()));
 
         // Fetch all event instances
         instances = m_om->itemOccurrences(event, QDateTime(QDate(2010,1,1), QTime(0,0,0)), QDateTime(QDate(2010,12,31), QTime(23,59,59)), 0);
@@ -686,7 +686,7 @@ void tst_Maemo5Om::addWithIllegalParameters()
 
 void tst_Maemo5Om::getItemIds()
 {
-    QList<QOrganizerItemLocalId> generatedIds;
+    QList<QOrganizerItemId> generatedIds;
 
     // Create a set of items
     for (int i = 1; i < 11; ++i) {
@@ -697,7 +697,7 @@ void tst_Maemo5Om::getItemIds()
         event.setDisplayLabel("getItemIds");
         event.setDescription("Event");
         QVERIFY(m_om->saveItem(&event));
-        generatedIds << event.localId();
+        generatedIds << event.id();
 
         QOrganizerTodo todo;
         todo.setId(QOrganizerItemId());
@@ -705,7 +705,7 @@ void tst_Maemo5Om::getItemIds()
         todo.setDisplayLabel("getItemIds");
         todo.setDescription("Todo");
         QVERIFY(m_om->saveItem(&todo));
-        generatedIds << todo.localId();
+        generatedIds << todo.id();
 
         QOrganizerJournal journal;
         journal.setId(QOrganizerItemId());
@@ -713,14 +713,14 @@ void tst_Maemo5Om::getItemIds()
         journal.setDisplayLabel("getItemIds");
         journal.setDescription("Journal");
         QVERIFY(m_om->saveItem(&journal));
-        generatedIds << journal.localId();
+        generatedIds << journal.id();
     }
 
     // Get items ids
-    QList<QOrganizerItemLocalId> ids = m_om->itemIds(QDateTime(QDate(2010,3,1)), QDateTime(QDate(2010,3,11)), QOrganizerItemFilter());
+    QList<QOrganizerItemId> ids = m_om->itemIds(QDateTime(QDate(2010,3,1)), QDateTime(QDate(2010,3,11)), QOrganizerItemFilter());
 
     // Check that all the item ids exist in result
-    foreach(QOrganizerItemLocalId id, generatedIds) {
+    foreach(QOrganizerItemId id, generatedIds) {
         QVERIFY(ids.contains(id));
     }
 }
@@ -765,7 +765,7 @@ void tst_Maemo5Om::getItems()
         bool itemFound = false;
         for (int i = 0; i < items.count(); ++i) {
             QOrganizerItem curr = items[i];
-            if (curr.localId() == item.localId()) {
+            if (curr.id() == item.id()) {
                 QCOMPARE(curr.type(), item.type());
                 itemFound = true;
                 break;
@@ -800,7 +800,7 @@ void tst_Maemo5Om::getItemOccurrences()
     // Save event
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
     QVERIFY(!event.guid().isEmpty());
 
@@ -846,11 +846,11 @@ void tst_Maemo5Om::setRecurrenceDates()
     // Save event
     QVERIFY(m_om->saveItem(&event));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event.id().localId().isNull());
+    QVERIFY(!event.id().isNull());
     QVERIFY(event.id().managerUri().contains(managerName));
     QVERIFY(!event.guid().isEmpty());
 
-    QOrganizerEvent fetchedEvent = static_cast<QOrganizerEvent>(m_om->item(event.id().localId()));
+    QOrganizerEvent fetchedEvent = static_cast<QOrganizerEvent>(m_om->item(event.id()));
     QSet<QDate> fetchedRecurrenceDates = fetchedEvent.recurrenceDates();
 
     QCOMPARE(recurrenceDates, fetchedRecurrenceDates);
@@ -999,7 +999,7 @@ void tst_Maemo5Om::saveItemsToNewCollection()
     // Save
     QVERIFY(m_om->saveItem(&event1));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!event1.id().localId().isNull());
+    QVERIFY(!event1.id().isNull());
     QVERIFY(event1.id().managerUri().contains(managerName));
     QVERIFY(!event1.guid().isEmpty());
 
@@ -1022,7 +1022,7 @@ void tst_Maemo5Om::saveItemsToNewCollection()
     QVERIFY(m_om->saveItems(&items));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
     foreach (QOrganizerItem item, items) {
-        QVERIFY(!item.id().localId().isNull());
+        QVERIFY(!item.id().isNull());
         QVERIFY(item.id().managerUri().contains(managerName));
         QVERIFY(!item.guid().isEmpty());
     }
@@ -1042,7 +1042,7 @@ void tst_Maemo5Om::saveItemsToNewCollection()
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
     QVERIFY(m_om->errorMap().count() == 0);
     foreach ( QOrganizerItem item2, items ) {
-        QVERIFY(!item2.id().localId().isNull());
+        QVERIFY(!item2.id().isNull());
         QVERIFY(item2.id().managerUri().contains(managerName));
         QVERIFY(!item2.guid().isEmpty());
     }
@@ -1069,14 +1069,14 @@ void tst_Maemo5Om::saveItemsToNewCollection()
     // Save event
     QVERIFY(m_om->saveItem(&recurrenceEvent));
     QCOMPARE(m_om->error(), QOrganizerManager::NoError);
-    QVERIFY(!recurrenceEvent.id().localId().isNull());
+    QVERIFY(!recurrenceEvent.id().isNull());
     QVERIFY(recurrenceEvent.id().managerUri().contains(managerName));
     QVERIFY(!recurrenceEvent.guid().isEmpty());
 
     // Save an extra occurrence to the reccurring event
     QOrganizerEventOccurrence recurrenceEventOccurrence;
     recurrenceEventOccurrence.setOriginalDate(recurrenceEvent.startDateTime().date());
-    recurrenceEventOccurrence.setParentLocalId(recurrenceEvent.localId());
+    recurrenceEventOccurrence.setParentId(recurrenceEvent.id());
     recurrenceEventOccurrence.setStartDateTime(QDateTime(QDate(2010,8,31), QTime(14,0,0)));
     recurrenceEventOccurrence.setEndDateTime(QDateTime(QDate(2010,8,31), QTime(15,0,0)));
     recurrenceEventOccurrence.setDisplayLabel("saveItemsToNewCollection, Extra occurrence");
@@ -1088,9 +1088,9 @@ void tst_Maemo5Om::saveItemsToNewCollection()
     QCOMPARE(recurrenceEventOccurrence.collectionId(), newCollection.id());
 
     // Try to fetch items
-    QOrganizerItem f1 = m_om->item(event1.localId());
-    QOrganizerItem f2 = m_om->item(items.at(0).localId());
-    QOrganizerItem f3 = m_om->item(items2.at(0).localId());
+    QOrganizerItem f1 = m_om->item(event1.id());
+    QOrganizerItem f2 = m_om->item(items.at(0).id());
+    QOrganizerItem f3 = m_om->item(items2.at(0).id());
 
     QCOMPARE(f1.id(), event1.id());
     QCOMPARE(f1.guid(), event1.guid());
@@ -1124,32 +1124,32 @@ void tst_Maemo5Om::saveItemsToNewCollection()
     QList<QOrganizerItemSortOrder> noSort;
 
     // Get all item ids of the new collection
-    QList<QOrganizerItemLocalId> newCollectionItemIds = m_om->itemIds(newCollectionFilter, noSort);
+    QList<QOrganizerItemId> newCollectionItemIds = m_om->itemIds(newCollectionFilter, noSort);
     QCOMPARE(newCollectionItemIds.count(), 5);
-    QVERIFY(newCollectionItemIds.contains(event1.localId()));
-    QVERIFY(newCollectionItemIds.contains(items.at(0).localId()));
-    QVERIFY(newCollectionItemIds.contains(items2.at(0).localId()));
-    QVERIFY(newCollectionItemIds.contains(recurrenceEvent.localId()));
-    QVERIFY(newCollectionItemIds.contains(recurrenceEventOccurrence.localId()));
+    QVERIFY(newCollectionItemIds.contains(event1.id()));
+    QVERIFY(newCollectionItemIds.contains(items.at(0).id()));
+    QVERIFY(newCollectionItemIds.contains(items2.at(0).id()));
+    QVERIFY(newCollectionItemIds.contains(recurrenceEvent.id()));
+    QVERIFY(newCollectionItemIds.contains(recurrenceEventOccurrence.id()));
 
     // Get all item ids of the default collection
-    QList<QOrganizerItemLocalId> defaultCollectionItemIds = m_om->itemIds(defaultCollectionFilter, noSort);
+    QList<QOrganizerItemId> defaultCollectionItemIds = m_om->itemIds(defaultCollectionFilter, noSort);
 
     // Get all item ids of the union collection
-    QList<QOrganizerItemLocalId> unionItemIds = m_om->itemIds(unionFilter, noSort);
+    QList<QOrganizerItemId> unionItemIds = m_om->itemIds(unionFilter, noSort);
 
     // Number of item ids in the new collection + number of ids in the default collection
     // should match to the number of ids in union
     QCOMPARE(newCollectionItemIds.count() + defaultCollectionItemIds.count(), unionItemIds.count());
 
     // Get all item ids of the intersection collection
-    QList<QOrganizerItemLocalId> intersectionItemIds = m_om->itemIds(intersectionFilter, noSort);
+    QList<QOrganizerItemId> intersectionItemIds = m_om->itemIds(intersectionFilter, noSort);
 
     // There should be no items that exist in both collections
     QCOMPARE(intersectionItemIds.count(), 0);
 
     // When no filtering is set, all the item ids should be returned ( = equal to number of ids with union filtering)
-    QList<QOrganizerItemLocalId> noFilteringItemIds = m_om->itemIds(noFilter, noSort);
+    QList<QOrganizerItemId> noFilteringItemIds = m_om->itemIds(noFilter, noSort);
     QCOMPARE(noFilteringItemIds.count(), unionItemIds.count());
 
     // Get all items of the new collection
@@ -1372,7 +1372,7 @@ void tst_Maemo5Om::testReminders()
     QVERIFY(m_om->saveItem(&event));
 
     // Fetch event
-    QOrganizerItem fetchItem = m_om->item(event.localId());
+    QOrganizerItem fetchItem = m_om->item(event.id());
     QOrganizerItemVisualReminder fetchEventReminder = fetchItem.detail<QOrganizerItemVisualReminder>();
     QCOMPARE(fetchEventReminder.dataUrl(), eventReminder.dataUrl());
     QCOMPARE(fetchEventReminder.message(), eventReminder.message());
@@ -1397,7 +1397,7 @@ void tst_Maemo5Om::testReminders()
     QVERIFY(m_om->saveItem(&todo));
 
     // Fetch todo
-    QOrganizerItem fetchTodo = m_om->item(todo.localId());
+    QOrganizerItem fetchTodo = m_om->item(todo.id());
     QOrganizerItemVisualReminder fetchTodoReminder = fetchTodo.detail<QOrganizerItemVisualReminder>();
     QCOMPARE(fetchTodoReminder.dataUrl(), todoReminder.dataUrl());
     QCOMPARE(fetchTodoReminder.message(), todoReminder.message());
diff --git a/plugins/organizer/skeleton/qorganizerskeleton.cpp b/plugins/organizer/skeleton/qorganizerskeleton.cpp
index 5c38e31478..40436f7ee2 100644
--- a/plugins/organizer/skeleton/qorganizerskeleton.cpp
+++ b/plugins/organizer/skeleton/qorganizerskeleton.cpp
@@ -84,10 +84,10 @@ QOrganizerItemSkeletonEngineLocalId::QOrganizerItemSkeletonEngineLocalId()
 
       This default constructor should not be used when returning a null id,
       but is provided in order to allow use of the ids in a list, and as an
-      enabler for the implementation of QOrganizerItemLocalId.
+      enabler for the implementation of QOrganizerItemId.
 
       When returning a null id, the backend should simply return a default
-      constructed QOrganizerItemLocalId.
+      constructed QOrganizerItemId.
 
       In this example, we use just a single quint32 to identify the item,
       however your engine may require more information in order to uniquely
@@ -108,8 +108,8 @@ QOrganizerItemSkeletonEngineLocalId::QOrganizerItemSkeletonEngineLocalId(quint32
       engine code.
 
       In particular, you will most likely be returning to clients an id by calling:
-      QOrganizerItemLocalId id(new QOrganizerItemSkeletonEngineLocalId(3));
-      or something similar.  Note that the QOrganizerItemLocalId constructor which
+      QOrganizerItemId id(new QOrganizerItemSkeletonEngineLocalId(3));
+      or something similar.  Note that the QOrganizerItemId constructor which
       takes a QOrganizerItemEngineLocalId pointer as a parameter takes ownership
       of that pointer (and so controls its lifetime).
      */
@@ -131,7 +131,7 @@ bool QOrganizerItemSkeletonEngineLocalId::isEqualTo(const QOrganizerItemEngineLo
     /*
       TODO
 
-      The isEqualTo(other) function is called by the QOrganizerItemLocalId::operator==(other) function.
+      The isEqualTo(other) function is called by the QOrganizerItemId::operator==(other) function.
       You must implement this in terms of the data members which your class contains.
 
       An example implementation is provided below, for the case where only a single quint32
@@ -149,7 +149,7 @@ bool QOrganizerItemSkeletonEngineLocalId::isLessThan(const QOrganizerItemEngineL
     /*
       TODO
 
-      The isLessThan(other) function is called by the QOrganizerItemLocalId::operator<(other) function.
+      The isLessThan(other) function is called by the QOrganizerItemId::operator<(other) function.
       You must implement this in terms of the data members which your class contains.
 
       An example implementation is provided below, for the case where only a single quint32
@@ -165,7 +165,7 @@ uint QOrganizerItemSkeletonEngineLocalId::engineLocalIdType() const
     /*
       TODO
 
-      The engine-local id type value is used by QOrganizerItemLocalId to ensure that
+      The engine-local id type value is used by QOrganizerItemId to ensure that
       comparisons are occurring between ids of the same engine-specific type.
       Such comparisons would return false if the types are not equal.
 
@@ -182,12 +182,17 @@ uint QOrganizerItemSkeletonEngineLocalId::engineLocalIdType() const
     return qHash(QString(QLatin1String("skeleton")));
 }
 
+QString QOrganizerItemSkeletonEngineLocalId::managerUri() const
+{
+    return QString::fromLatin1("QOrganizer:skeleton:");
+}
+
 QOrganizerItemEngineLocalId* QOrganizerItemSkeletonEngineLocalId::clone() const
 {
     /*
       TODO
 
-      When a QOrganizerItemLocalId is copied or assigned, it performs a clone of
+      When a QOrganizerItemId is copied or assigned, it performs a clone of
       the engine-specific local id.  This function is called in that case.
 
       Implement this function so that the data members of your engine-specific id
@@ -203,7 +208,7 @@ QOrganizerItemEngineLocalId* QOrganizerItemSkeletonEngineLocalId::clone() const
 }
 
 #ifndef QT_NO_DEBUG_STREAM
-QDebug QOrganizerItemSkeletonEngineLocalId::debugStreamOut(QDebug dbg)
+QDebug& QOrganizerItemSkeletonEngineLocalId::debugStreamOut(QDebug& dbg)
 {
     /*
       TODO
@@ -560,7 +565,7 @@ QList<QOrganizerItem> QOrganizerItemSkeletonEngine::itemOccurrences(const QOrgan
     return QOrganizerManagerEngine::itemOccurrences(parentItem, periodStart, periodEnd, maxCount, fetchHint, error);
 }
 
-QList<QOrganizerItemLocalId> QOrganizerItemSkeletonEngine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const
+QList<QOrganizerItemId> QOrganizerItemSkeletonEngine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const
 {
     /*
         TODO
@@ -615,7 +620,7 @@ QList<QOrganizerItem> QOrganizerItemSkeletonEngine::items(const QDateTime& start
 
     /* An alternative formulation, depending on how your engine is implemented is just:
 
-        foreach(const QOrganizerItemLocalId& id, itemIds(filter, sortOrders, error)) {
+        foreach(const QOrganizerItemId& id, itemIds(filter, sortOrders, error)) {
             ret.append(item(id, fetchHint, error);
         }
      */
@@ -623,7 +628,7 @@ QList<QOrganizerItem> QOrganizerItemSkeletonEngine::items(const QDateTime& start
     return ret;
 }
 
-QOrganizerItem QOrganizerItemSkeletonEngine::item(const QOrganizerItemLocalId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const
+QOrganizerItem QOrganizerItemSkeletonEngine::item(const QOrganizerItemId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const
 {
     /*
         TODO
@@ -660,7 +665,7 @@ bool QOrganizerItemSkeletonEngine::saveItems(QList<QOrganizerItem>* items, QMap<
 
 }
 
-bool QOrganizerItemSkeletonEngine::removeItems(const QList<QOrganizerItemLocalId>& itemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error)
+bool QOrganizerItemSkeletonEngine::removeItems(const QList<QOrganizerItemId>& itemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error)
 {
     /*
         TODO
diff --git a/plugins/organizer/skeleton/qorganizerskeleton_p.h b/plugins/organizer/skeleton/qorganizerskeleton_p.h
index 968c53c943..515c11f753 100644
--- a/plugins/organizer/skeleton/qorganizerskeleton_p.h
+++ b/plugins/organizer/skeleton/qorganizerskeleton_p.h
@@ -129,10 +129,11 @@ public:
     bool isLessThan(const QOrganizerItemEngineLocalId* other) const;
 
     uint engineLocalIdType() const;
+    QString managerUri() const;
     QOrganizerItemEngineLocalId* clone() const;
 
 #ifndef QT_NO_DEBUG_STREAM
-    QDebug debugStreamOut(QDebug dbg);
+    QDebug& debugStreamOut(QDebug& dbg);
 #endif
 #ifndef QT_NO_DATASTREAM
     QDataStream& dataStreamOut(QDataStream& out);
@@ -181,12 +182,12 @@ public:
     int managerVersion() const;
 
     QList<QOrganizerItem> itemOccurrences(const QOrganizerItem& parentItem, const QDateTime& periodStart, const QDateTime& periodEnd, int maxCount, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
-    QList<QOrganizerItemLocalId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const;
+    QList<QOrganizerItemId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const;
     QList<QOrganizerItem> items(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
-    QOrganizerItem item(const QOrganizerItemLocalId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
+    QOrganizerItem item(const QOrganizerItemId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
 
     bool saveItems(QList<QOrganizerItem>* items, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
-    bool removeItems(const QList<QOrganizerItemLocalId>& itemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
+    bool removeItems(const QList<QOrganizerItemId>& itemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
 
     /* Definitions - Accessors and Mutators */
     QMap<QString, QOrganizerItemDetailDefinition> detailDefinitions(const QString& itemType, QOrganizerManager::Error* error) const;
diff --git a/plugins/organizer/symbian/organizeritemrequestserviceprovider.cpp b/plugins/organizer/symbian/organizeritemrequestserviceprovider.cpp
index d650d15727..2107068923 100644
--- a/plugins/organizer/symbian/organizeritemrequestserviceprovider.cpp
+++ b/plugins/organizer/symbian/organizeritemrequestserviceprovider.cpp
@@ -364,7 +364,7 @@ void COrganizerItemRequestsServiceProvider::FetchItemIds()
     QOrganizerItemLocalIdFetchRequest *req = static_cast<QOrganizerItemLocalIdFetchRequest *>(iReq);
     QOrganizerManager::Error error(QOrganizerManager::NoError);
     QList<QOrganizerItemLocalId> itemIds = iOrganizerItemManagerEngine.itemIds(req->startDate(), req->endDate(), req->filter(), req->sorting(), &error);
-    QOrganizerManagerEngine::updateItemLocalIdFetchRequest(
+    QOrganizerManagerEngine::updateItemIdFetchRequest(
         req, itemIds, error, QOrganizerAbstractRequest::FinishedState);
 }
 
diff --git a/plugins/organizer/symbian/organizersymbianutils.cpp b/plugins/organizer/symbian/organizersymbianutils.cpp
index d750aaa4a8..6a9626004a 100644
--- a/plugins/organizer/symbian/organizersymbianutils.cpp
+++ b/plugins/organizer/symbian/organizersymbianutils.cpp
@@ -127,9 +127,9 @@ QOrganizerCollectionLocalId toCollectionLocalId(quint64 collectionId)
     return QOrganizerCollectionLocalId(new QOrganizerCollectionSymbianEngineLocalId(collectionId));
 }
 
-QOrganizerItemLocalId toItemLocalId(quint64 collectionId, quint32 itemId)
+QOrganizerItemId toItemLocalId(quint64 collectionId, quint32 itemId)
 {
-    return QOrganizerItemLocalId(new QOrganizerItemSymbianEngineLocalId(collectionId, itemId));
+    return QOrganizerItemId(new QOrganizerItemSymbianEngineLocalId(collectionId, itemId));
 }
 
 TCalLocalUid toTCalLocalUid(const QOrganizerItemLocalId& itemLocalId)
diff --git a/plugins/organizer/symbian/organizersymbianutils.h b/plugins/organizer/symbian/organizersymbianutils.h
index d36ad2a7d3..1d9a3f25fd 100644
--- a/plugins/organizer/symbian/organizersymbianutils.h
+++ b/plugins/organizer/symbian/organizersymbianutils.h
@@ -68,7 +68,7 @@ namespace OrganizerSymbianUtils
     TTime toTTime(const QDateTime &dateTime, Qt::TimeSpec timeSpec);
     QDateTime toQDateTime(const TTime &time, Qt::TimeSpec timeSpec);
     QOrganizerCollectionLocalId toCollectionLocalId(quint64 collectionId);
-    QOrganizerItemLocalId toItemLocalId(quint64 collectionId, quint32 itemId);
+    QOrganizerItemId toItemLocalId(quint64 collectionId, quint32 itemId);
     TCalLocalUid toTCalLocalUid(const QOrganizerItemLocalId& itemLocalId);
     quint64 toTCalCollectionId(const QOrganizerItemLocalId& itemLocalId);
     QOrganizerCollectionLocalId getCollectionLocalId(const QOrganizerItemLocalId& itemLocalId);
diff --git a/plugins/organizer/symbian/qorganizersymbian.cpp b/plugins/organizer/symbian/qorganizersymbian.cpp
index 4dfb5a1c23..3765f6eef0 100644
--- a/plugins/organizer/symbian/qorganizersymbian.cpp
+++ b/plugins/organizer/symbian/qorganizersymbian.cpp
@@ -499,15 +499,11 @@ void QOrganizerItemSymbianEngine::toItemOccurrencesL(
             break;
 
         bool isException = (calInstance->Entry().RecurrenceIdL().TimeUtcL() != Time::NullTTime());
-        QOrganizerItemId id;
-        // Set local id if this is an exceptional item
+        // Set id if this is an exceptional item
         if (isException) {
-            QOrganizerItemLocalId instanceEntryId(new QOrganizerItemSymbianEngineLocalId(
-                localCollectionIdValue, calInstance->Entry().LocalUidL()));
-            id.setLocalId(instanceEntryId);
+            itemOccurrence.setId(QOrganizerItemId(new QOrganizerItemSymbianEngineLocalId(
+                localCollectionIdValue, calInstance->Entry().LocalUidL())));
         }
-        id.setManagerUri(managerUri());
-        itemOccurrence.setId(id);
 
         // Set parent id
         TCalLocalUid parentLocalUid(0);
@@ -716,10 +712,7 @@ QOrganizerItem QOrganizerItemSymbianEngine::itemL(const QOrganizerItemLocalId& i
     CleanupStack::PopAndDestroy(calEntry);
     
     // Set item id
-    QOrganizerItemId id;
-    id.setLocalId(itemId);
-    id.setManagerUri(managerUri());
-    item.setId(id);    
+    item.setId(itemId);
 
     // Set collection id
     QOrganizerCollectionId cid;
@@ -824,11 +817,8 @@ void QOrganizerItemSymbianEngine::saveItemL(QOrganizerItem *item,
     // Transform details that are available/updated after saving    
     m_itemTransform.toItemPostSaveL(*entry, item, managerUri());
     
-    // Update local id
-    QOrganizerItemId itemId;
-    itemId.setManagerUri(managerUri());
-    itemId.setLocalId(toItemLocalId(m_collections[collectionLocalId].calCollectionId(), entry->LocalUidL()));
-    item->setId(itemId);
+    // Update id
+    item->setId(toItemLocalId(m_collections[collectionLocalId].calCollectionId(), entry->LocalUidL()));
 
     // Set collection id
     QOrganizerCollectionId cid;
diff --git a/plugins/organizer/symbian/tsrc/tst_symbianom/tst_symbianom.cpp b/plugins/organizer/symbian/tsrc/tst_symbianom/tst_symbianom.cpp
index 5e1b800c61..93cda24f51 100644
--- a/plugins/organizer/symbian/tsrc/tst_symbianom/tst_symbianom.cpp
+++ b/plugins/organizer/symbian/tsrc/tst_symbianom/tst_symbianom.cpp
@@ -406,10 +406,10 @@ void tst_SymbianOm::uniqueIds()
     QVERIFY(todo.localId() == localId); // local id should remain the same
     
     // Change manager uri and save again. Should fail.
-    QOrganizerItemId id = todo.id();
-    id.setManagerUri("foobar");
-    todo.setId(id);
-    QVERIFY(!m_om->saveItem(&todo));    
+    todo.setId(QOrganizerItemId());
+    QVERIFY(!m_om->saveItem(&todo));
+
+    // TODO: create a read invalid id, and try to save with that also
 }
 
 void tst_SymbianOm::timeStamp()
diff --git a/src/organizer/details/qorganizeritemdetails.cpp b/src/organizer/details/qorganizeritemdetails.cpp
index 04a7f89934..76f0e668a5 100644
--- a/src/organizer/details/qorganizeritemdetails.cpp
+++ b/src/organizer/details/qorganizeritemdetails.cpp
@@ -261,12 +261,12 @@ Q_DEFINE_LATIN1_CONSTANT(QOrganizerItemGuid::FieldGuid, "Guid");
 Q_DEFINE_LATIN1_CONSTANT(QOrganizerItemParent::DefinitionName, "Parent");
 
 /*!
-   \variable QOrganizerItemParent::FieldParentLocalId
+   \variable QOrganizerItemParent::FieldParentId
 
    The constant key for the field in which the local id of the parent recurrent event
    is stored in details of the QOrganizerItemParent type.
  */
-Q_DEFINE_LATIN1_CONSTANT(QOrganizerItemParent::FieldParentLocalId, "ParentLocalId");
+Q_DEFINE_LATIN1_CONSTANT(QOrganizerItemParent::FieldParentId, "ParentId");
 
 
 /*!
@@ -278,12 +278,12 @@ Q_DEFINE_LATIN1_CONSTANT(QOrganizerItemParent::FieldParentLocalId, "ParentLocalI
 Q_DEFINE_LATIN1_CONSTANT(QOrganizerItemParent::FieldOriginalDate, "OriginalDate");
 
 /*!
-   \fn QOrganizerItemParent::parentLocalId() const
+   \fn QOrganizerItemParent::parentId() const
     Returns the local id of the item instance origin's parent item.
  */
 
 /*!
-   \fn QOrganizerItemParent::setParentLocalId(const QOrganizerItemLocalId& parentId)
+   \fn QOrganizerItemParent::setParentId(const QOrganizerItemId& parentId)
     Sets the parent id of this instance origin item to \a parentId.
  */
 
diff --git a/src/organizer/details/qorganizeritemparent.h b/src/organizer/details/qorganizeritemparent.h
index 21bba2cf3e..e45846545a 100644
--- a/src/organizer/details/qorganizeritemparent.h
+++ b/src/organizer/details/qorganizeritemparent.h
@@ -57,16 +57,16 @@ class Q_ORGANIZER_EXPORT QOrganizerItemParent : public QOrganizerItemDetail
 public:
 #ifdef Q_QDOC
     static const QLatin1Constant DefinitionName;
-    static const QLatin1Constant FieldParentLocalId;
+    static const QLatin1Constant FieldParentId;
     static const QLatin1Constant FieldOriginalDate;
 #else
     Q_DECLARE_CUSTOM_ORGANIZER_DETAIL(QOrganizerItemParent, "Parent")
-    Q_DECLARE_LATIN1_CONSTANT(FieldParentLocalId, "ParentLocalId");
+    Q_DECLARE_LATIN1_CONSTANT(FieldParentId, "ParentId");
     Q_DECLARE_LATIN1_CONSTANT(FieldOriginalDate, "OriginalDate");
 #endif
 
-    void setParentLocalId(const QOrganizerItemLocalId& parentId) {setValue(FieldParentLocalId, QVariant::fromValue(parentId));}
-    QOrganizerItemLocalId parentLocalId() const {return variantValue(FieldParentLocalId).value<QOrganizerItemLocalId>();}
+    void setParentId(const QOrganizerItemId& parentId) {setValue(FieldParentId, QVariant::fromValue(parentId));}
+    QOrganizerItemId parentId() const {return variantValue(FieldParentId).value<QOrganizerItemId>();}
 
 
     void setOriginalDate(const QDate& date) {setValue(FieldOriginalDate, date);}
diff --git a/src/organizer/engines/qorganizeritemmemorybackend.cpp b/src/organizer/engines/qorganizeritemmemorybackend.cpp
index 4292ce0086..59ec8bb132 100644
--- a/src/organizer/engines/qorganizeritemmemorybackend.cpp
+++ b/src/organizer/engines/qorganizeritemmemorybackend.cpp
@@ -143,6 +143,12 @@ uint QOrganizerItemMemoryEngineLocalId::engineLocalIdType() const
     return qHash(QString(QLatin1String("memory")));
 }
 
+QString QOrganizerItemMemoryEngineLocalId::managerUri() const
+{
+    // TODO: fix this !!
+    return QString::fromLatin1("QOrganizer:memory:");
+}
+
 QOrganizerItemEngineLocalId* QOrganizerItemMemoryEngineLocalId::clone() const
 {
     QOrganizerItemMemoryEngineLocalId *myClone = new QOrganizerItemMemoryEngineLocalId;
@@ -152,7 +158,7 @@ QOrganizerItemEngineLocalId* QOrganizerItemMemoryEngineLocalId::clone() const
 }
 
 #ifndef QT_NO_DEBUG_STREAM
-QDebug QOrganizerItemMemoryEngineLocalId::debugStreamOut(QDebug dbg)
+QDebug& QOrganizerItemMemoryEngineLocalId::debugStreamOut(QDebug& dbg)
 {
     dbg.nospace() << "QOrganizerItemMemoryEngineLocalId(" << m_localCollectionId << ", " << m_localItemId << ")";
     return dbg.maybeSpace();
@@ -354,7 +360,7 @@ QMap<QString, QString> QOrganizerItemMemoryEngine::managerParameters() const
 }
 
 /*! \reimp */
-QOrganizerItem QOrganizerItemMemoryEngine::item(const QOrganizerItemLocalId& organizeritemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const
+QOrganizerItem QOrganizerItemMemoryEngine::item(const QOrganizerItemId& organizeritemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const
 {
     Q_UNUSED(fetchHint); // no optimisations are possible in the memory backend; ignore the fetch hint.
     int index = d->m_organizeritemIds.indexOf(organizeritemId);
@@ -369,7 +375,7 @@ QOrganizerItem QOrganizerItemMemoryEngine::item(const QOrganizerItemLocalId& org
 }
 
 /*! \reimp */
-QList<QOrganizerItemLocalId> QOrganizerItemMemoryEngine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const
+QList<QOrganizerItemId> QOrganizerItemMemoryEngine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const
 {
     /* Special case the fast case */
     if (startDate.isNull() && endDate.isNull() && filter.type() == QOrganizerItemFilter::DefaultFilter && sortOrders.count() == 0) {
@@ -713,8 +719,8 @@ QList<QOrganizerItem> QOrganizerItemMemoryEngine::internalItemOccurrences(const
     if (includeExceptions) {
         // first, retrieve all persisted instances (exceptions) which occur between the specified datetimes.
         QOrganizerItemDetailFilter parentFilter;
-        parentFilter.setDetailDefinitionName(QOrganizerItemParent::DefinitionName, QOrganizerItemParent::FieldParentLocalId);
-        parentFilter.setValue(QVariant::fromValue(parentItem.localId()));
+        parentFilter.setDetailDefinitionName(QOrganizerItemParent::DefinitionName, QOrganizerItemParent::FieldParentId);
+        parentFilter.setValue(QVariant::fromValue(parentItem.id()));
         foreach(const QOrganizerItem&currException, d->m_organizeritems) {
             if (QOrganizerManagerEngine::testFilter(parentFilter, currException)) {
                 QDateTime lowerBound;
@@ -817,7 +823,7 @@ QOrganizerItem QOrganizerItemMemoryEngine::generateOccurrence(const QOrganizerIt
 
     // add the detail which identifies exactly which instance this item is.
     QOrganizerItemParent currOrigin;
-    currOrigin.setParentLocalId(parentItem.localId());
+    currOrigin.setParentId(parentItem.id());
     currOrigin.setOriginalDate(rdate.date());
     occDets.append(currOrigin);
 
@@ -923,7 +929,7 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
     }
 
     // check to see if this organizer item already exists
-    int index = d->m_organizeritemIds.indexOf(theOrganizerItem->id().localId());
+    int index = d->m_organizeritemIds.indexOf(theOrganizerItem->id());
     if (index != -1) {
         /* We also need to check that there are no modified create only details */
         QOrganizerItem oldOrganizerItem = d->m_organizeritems.at(index);
@@ -936,8 +942,8 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
         // check that the old and new collection is the same (ie, not attempting to save to a different collection)
         if (targetCollectionId.isNull()) {
             // it already exists, so save it where it already exists.
-            targetCollectionId = d->m_itemsInCollections.key(theOrganizerItem->localId());
-        } else if (!d->m_itemsInCollections.values(targetCollectionId).contains(theOrganizerItem->localId())) {
+            targetCollectionId = d->m_itemsInCollections.key(theOrganizerItem->id());
+        } else if (!d->m_itemsInCollections.values(targetCollectionId).contains(theOrganizerItem->id())) {
             // the given collection id was non-null but doesn't already contain this item.  error.
             *error = QOrganizerManager::InvalidCollectionError;
             return false;
@@ -954,11 +960,9 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
 
         // Looks ok, so continue
         d->m_organizeritems.replace(index, *theOrganizerItem);
-        changeSet.insertChangedItem(theOrganizerItem->localId());
+        changeSet.insertChangedItem(theOrganizerItem->id());
     } else {
         // id does not exist; if not zero, fail.
-        QOrganizerItemId newId;
-        newId.setManagerUri(managerUri());
         if (!theOrganizerItem->id().isNull()) {
             // the ID is not empty, and it doesn't identify an existing organizer item in our database either.
             *error = QOrganizerManager::DoesNotExistError;
@@ -985,9 +989,8 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
         QOrganizerItemMemoryEngineLocalId* newMemoryEngineLocalId = new QOrganizerItemMemoryEngineLocalId;
         newMemoryEngineLocalId->m_localCollectionId = static_cast<QOrganizerCollectionMemoryEngineLocalId*>(QOrganizerManagerEngine::engineLocalCollectionId(targetCollectionId))->m_localCollectionId;
         newMemoryEngineLocalId->m_localItemId = nextOrganizerItemId;
-        newId.setLocalId(QOrganizerItemLocalId(newMemoryEngineLocalId));
-        theOrganizerItem->setId(newId);
-        // note: do NOT delete the QOrganizerItemMemoryEngineLocalId -- the QOrganizerItemLocalId ctor takes ownership of it.
+        theOrganizerItem->setId(QOrganizerItemId(newMemoryEngineLocalId));
+        // note: do NOT delete the QOrganizerItemMemoryEngineLocalId -- the QOrganizerItemId ctor takes ownership of it.
 
         if (!fixOccurrenceReferences(theOrganizerItem, error)) {
             return false;
@@ -1001,7 +1004,7 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
             // update the event by adding an EX-DATE which corresponds to the original date of the occurrence being saved.
             QOrganizerManager::Error tempError = QOrganizerManager::NoError;
             QOrganizerItemParent origin = theOrganizerItem->detail<QOrganizerItemParent>();
-            QOrganizerItemLocalId parentId = origin.parentLocalId();
+            QOrganizerItemId parentId = origin.parentId();
 
             // for occurrences, if given a null collection id, save it in the same collection as the parent.
             // otherwise, ensure that the parent is in the same collection.  You cannot save an exception to a different collection than the parent.
@@ -1011,8 +1014,7 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
                     *error = QOrganizerManager::UnspecifiedError; // this should never occur; parent should _always_ be in a collection.
                     return false;
                 }
-                newId.setLocalId(QOrganizerItemLocalId(QOrganizerItemLocalId(new QOrganizerItemMemoryEngineLocalId(static_cast<QOrganizerCollectionMemoryEngineLocalId*>(QOrganizerManagerEngine::engineLocalCollectionId(targetCollectionId))->m_localCollectionId, nextOrganizerItemId))));
-                theOrganizerItem->setId(newId);
+                theOrganizerItem->setId(QOrganizerItemId(new QOrganizerItemMemoryEngineLocalId(static_cast<QOrganizerCollectionMemoryEngineLocalId*>(QOrganizerManagerEngine::engineLocalCollectionId(targetCollectionId))->m_localCollectionId, nextOrganizerItemId)));
             } else if (!d->m_itemsInCollections.values(targetCollectionId).contains(parentId)) {
                 // nope, the specified collection doesn't contain the parent.  error.
                 *error = QOrganizerManager::InvalidCollectionError;
@@ -1025,15 +1027,15 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
             if (!currentExceptionDates.contains(originalDate)) {
                 currentExceptionDates << originalDate;
                 parentEvent.setExceptionDates(currentExceptionDates);
-                int parentEventIndex = d->m_organizeritemIds.indexOf(parentEvent.localId());
+                int parentEventIndex = d->m_organizeritemIds.indexOf(parentEvent.id());
                 d->m_organizeritems.replace(parentEventIndex, parentEvent);
-                changeSet.insertChangedItem(parentEvent.localId()); // is this correct?  it's an exception, so change parent?
+                changeSet.insertChangedItem(parentEvent.id()); // is this correct?  it's an exception, so change parent?
             }
         } else if (theOrganizerItem->type() == QOrganizerItemType::TypeTodoOccurrence) {
             // update the todo by adding an EX-DATE which corresponds to the original date of the occurrence being saved.
             QOrganizerManager::Error tempError = QOrganizerManager::NoError;
             QOrganizerItemParent origin = theOrganizerItem->detail<QOrganizerItemParent>();
-            QOrganizerItemLocalId parentId = origin.parentLocalId();
+            QOrganizerItemId parentId = origin.parentId();
 
             // for occurrences, if given a null collection id, save it in the same collection as the parent.
             // otherwise, ensure that the parent is in the same collection.  You cannot save an exception to a different collection than the parent.
@@ -1043,8 +1045,7 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
                     *error = QOrganizerManager::UnspecifiedError; // this should never occur; parent should _always_ be in a collection.
                     return false;
                 }
-                newId.setLocalId(QOrganizerItemLocalId(QOrganizerItemLocalId(new QOrganizerItemMemoryEngineLocalId(static_cast<QOrganizerCollectionMemoryEngineLocalId*>(QOrganizerManagerEngine::engineLocalCollectionId(targetCollectionId))->m_localCollectionId, nextOrganizerItemId))));
-                theOrganizerItem->setId(newId);
+               theOrganizerItem->setId(QOrganizerItemId(QOrganizerItemId(new QOrganizerItemMemoryEngineLocalId(static_cast<QOrganizerCollectionMemoryEngineLocalId*>(QOrganizerManagerEngine::engineLocalCollectionId(targetCollectionId))->m_localCollectionId, nextOrganizerItemId))));
             } else if (!d->m_itemsInCollections.values(targetCollectionId).contains(parentId)) {
                 // nope, the specified collection doesn't contain the parent.  error.
                 *error = QOrganizerManager::InvalidCollectionError;
@@ -1057,9 +1058,9 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
             if (!currentExceptionDates.contains(originalDate)) {
                 currentExceptionDates << originalDate;
                 parentTodo.setExceptionDates(currentExceptionDates);
-                int parentTodoIndex = d->m_organizeritemIds.indexOf(parentTodo.localId());
+                int parentTodoIndex = d->m_organizeritemIds.indexOf(parentTodo.id());
                 d->m_organizeritems.replace(parentTodoIndex, parentTodo);
-                changeSet.insertChangedItem(parentTodo.localId()); // is this correct?  it's an exception, so change parent?
+                changeSet.insertChangedItem(parentTodo.id()); // is this correct?  it's an exception, so change parent?
             }
         }
 
@@ -1072,10 +1073,10 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
         targetCompleteCollectionId.setLocalId(targetCollectionId);
         theOrganizerItem->setCollectionId(targetCompleteCollectionId);
         d->m_organizeritems.append(*theOrganizerItem);              // add organizer item to list
-        d->m_organizeritemIds.append(theOrganizerItem->localId());  // track the organizer item id.
-        d->m_itemsInCollections.insert(targetCollectionId, theOrganizerItem->localId());
+        d->m_organizeritemIds.append(theOrganizerItem->id());  // track the organizer item id.
+        d->m_itemsInCollections.insert(targetCollectionId, theOrganizerItem->id());
 
-        changeSet.insertAddedItem(theOrganizerItem->localId());
+        changeSet.insertAddedItem(theOrganizerItem->id());
 
         // XXX TODO: prior to all of this, need to check:
         // 1) is it an Occurrence item?
@@ -1090,7 +1091,7 @@ bool QOrganizerItemMemoryEngine::saveItem(QOrganizerItem* theOrganizerItem, QOrg
 }
 
 /*!
- * For Occurrence type items, ensure the ParentLocalId and the Guid are set consistently.  Returns
+ * For Occurrence type items, ensure the ParentId and the Guid are set consistently.  Returns
  * false and sets \a error on error, returns true otherwise.
  */
 bool QOrganizerItemMemoryEngine::fixOccurrenceReferences(QOrganizerItem* theItem, QOrganizerManager::Error* error)
@@ -1103,7 +1104,7 @@ bool QOrganizerItemMemoryEngine::fixOccurrenceReferences(QOrganizerItem* theItem
             *error = QOrganizerManager::InvalidOccurrenceError;
             return false;
         }
-        QOrganizerItemLocalId parentId = instanceOrigin.parentLocalId();
+        QOrganizerItemId parentId = instanceOrigin.parentId();
         if (!guid.isEmpty()) {
             if (!parentId.isNull()) {
                 QOrganizerManager::Error tempError;
@@ -1120,7 +1121,7 @@ bool QOrganizerItemMemoryEngine::fixOccurrenceReferences(QOrganizerItem* theItem
                 // find an item with the given guid
                 foreach (const QOrganizerItem& item, d->m_organizeritems) {
                     if (item.guid() == guid) {
-                        parentId = item.localId();
+                        parentId = item.id();
                         break;
                     }
                 }
@@ -1138,7 +1139,7 @@ bool QOrganizerItemMemoryEngine::fixOccurrenceReferences(QOrganizerItem* theItem
                 }
                 // found a matching item - set the parentId of the occurrence
                 QOrganizerItemParent origin = theItem->detail<QOrganizerItemParent>();
-                origin.setParentLocalId(parentId);
+                origin.setParentId(parentId);
                 theItem->saveDetail(&origin);
             }
         } else if (!parentId.isNull()) {
@@ -1204,7 +1205,7 @@ bool QOrganizerItemMemoryEngine::saveItems(QList<QOrganizerItem>* organizeritems
 
 /*! Removes the organizer item identified by the given \a organizeritemId, storing any error to \a error and
     filling the \a changeSet with ids of changed organizer items and relationships as required */
-bool QOrganizerItemMemoryEngine::removeItem(const QOrganizerItemLocalId& organizeritemId, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error)
+bool QOrganizerItemMemoryEngine::removeItem(const QOrganizerItemId& organizeritemId, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error)
 {
     int index = d->m_organizeritemIds.indexOf(organizeritemId);
 
@@ -1214,10 +1215,6 @@ bool QOrganizerItemMemoryEngine::removeItem(const QOrganizerItemLocalId& organiz
     }
 
     // remove the organizer item from the lists.
-    QOrganizerItemId thisOrganizerItem;
-    thisOrganizerItem.setManagerUri(managerUri());
-    thisOrganizerItem.setLocalId(organizeritemId);
-
     d->m_organizeritems.removeAt(index);
     d->m_organizeritemIds.removeAt(index);
     d->m_itemsInCollections.remove(d->m_itemsInCollections.key(organizeritemId), organizeritemId);
@@ -1228,7 +1225,7 @@ bool QOrganizerItemMemoryEngine::removeItem(const QOrganizerItemLocalId& organiz
 }
 
 /*! \reimp */
-bool QOrganizerItemMemoryEngine::removeItems(const QList<QOrganizerItemLocalId>& organizeritemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error)
+bool QOrganizerItemMemoryEngine::removeItems(const QList<QOrganizerItemId>& organizeritemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error)
 {
     if (organizeritemIds.count() == 0) {
         *error = QOrganizerManager::BadArgumentError;
@@ -1236,7 +1233,7 @@ bool QOrganizerItemMemoryEngine::removeItems(const QList<QOrganizerItemLocalId>&
     }
     
     QOrganizerItemChangeSet changeSet;
-    QOrganizerItemLocalId current;
+    QOrganizerItemId current;
     QOrganizerManager::Error operationError = QOrganizerManager::NoError;
     for (int i = 0; i < organizeritemIds.count(); i++) {
         current = organizeritemIds.at(i);
@@ -1359,7 +1356,7 @@ bool QOrganizerItemMemoryEngine::removeCollection(const QOrganizerCollectionLoca
     }
 
     // try to find the collection to remove it (and the items it contains)
-    QList<QOrganizerItemLocalId> itemsToRemove = d->m_itemsInCollections.values(collectionId);
+    QList<QOrganizerItemId> itemsToRemove = d->m_itemsInCollections.values(collectionId);
     for (int i = 0; i < d->m_organizerCollectionIds.size(); ++i) {
         if (d->m_organizerCollectionIds.at(i) == collectionId) {
             // found the collection to remove.  remove the items in the collection.
@@ -1572,17 +1569,17 @@ void QOrganizerItemMemoryEngine::performAsynchronousOperation(QOrganizerAbstract
 
         case QOrganizerAbstractRequest::ItemLocalIdFetchRequest:
         {
-            QOrganizerItemLocalIdFetchRequest* r = static_cast<QOrganizerItemLocalIdFetchRequest*>(currentRequest);
+            QOrganizerItemIdFetchRequest* r = static_cast<QOrganizerItemIdFetchRequest*>(currentRequest);
             QOrganizerItemFilter filter = r->filter();
             QList<QOrganizerItemSortOrder> sorting = r->sorting();
             QDateTime startDate = r->startDate();
             QDateTime endDate = r->endDate();
 
             QOrganizerManager::Error operationError = QOrganizerManager::NoError;
-            QList<QOrganizerItemLocalId> requestedOrganizerItemIds = itemIds(startDate, endDate, filter, sorting, &operationError);
+            QList<QOrganizerItemId> requestedOrganizerItemIds = itemIds(startDate, endDate, filter, sorting, &operationError);
 
             if (!requestedOrganizerItemIds.isEmpty() || operationError != QOrganizerManager::NoError)
-                updateItemLocalIdFetchRequest(r, requestedOrganizerItemIds, operationError, QOrganizerAbstractRequest::FinishedState);
+                updateItemIdFetchRequest(r, requestedOrganizerItemIds, operationError, QOrganizerAbstractRequest::FinishedState);
             else
                 updateRequestState(currentRequest, QOrganizerAbstractRequest::FinishedState);
         }
@@ -1605,7 +1602,7 @@ void QOrganizerItemMemoryEngine::performAsynchronousOperation(QOrganizerAbstract
         {
             QOrganizerItemRemoveRequest* r = static_cast<QOrganizerItemRemoveRequest*>(currentRequest);
             QOrganizerManager::Error operationError = QOrganizerManager::NoError;
-            QList<QOrganizerItemLocalId> organizeritemsToRemove = r->itemIds();
+            QList<QOrganizerItemId> organizeritemsToRemove = r->itemIds();
             QMap<int, QOrganizerManager::Error> errorMap;
 
             for (int i = 0; i < organizeritemsToRemove.size(); i++) {
diff --git a/src/organizer/engines/qorganizeritemmemorybackend_p.h b/src/organizer/engines/qorganizeritemmemorybackend_p.h
index 3282d0bbb7..c3dc4a36c1 100644
--- a/src/organizer/engines/qorganizeritemmemorybackend_p.h
+++ b/src/organizer/engines/qorganizeritemmemorybackend_p.h
@@ -89,10 +89,11 @@ public:
     bool isLessThan(const QOrganizerItemEngineLocalId* other) const;
 
     uint engineLocalIdType() const;
+    QString managerUri() const;
     QOrganizerItemEngineLocalId* clone() const;
 
 #ifndef QT_NO_DEBUG_STREAM
-    QDebug debugStreamOut(QDebug dbg);
+    QDebug& debugStreamOut(QDebug& dbg);
 #endif
 #ifndef QT_NO_DATASTREAM
     QDataStream& dataStreamOut(QDataStream& out);
@@ -148,10 +149,10 @@ public:
     QString m_id;                                  // the id parameter value
 
     QList<QOrganizerItem> m_organizeritems;                      // list of organizer items
-    QList<QOrganizerItemLocalId> m_organizeritemIds;             // list of organizer item Id's
+    QList<QOrganizerItemId> m_organizeritemIds;             // list of organizer item Id's
     QList<QOrganizerCollection> m_organizerCollections;          // list of collections
     QList<QOrganizerCollectionLocalId> m_organizerCollectionIds; // list of collection ids
-    QMultiMap<QOrganizerCollectionLocalId, QOrganizerItemLocalId> m_itemsInCollections; // map of collection ids to the ids of items the collection contains.
+    QMultiMap<QOrganizerCollectionLocalId, QOrganizerItemId> m_itemsInCollections; // map of collection ids to the ids of items the collection contains.
     QList<QString> m_definitionIds;                // list of definition types (id's)
     mutable QMap<QString, QMap<QString, QOrganizerItemDetailDefinition> > m_definitions; // map of organizer item type to map of definition name to definitions.
     quint32 m_nextOrganizerItemId; // the m_localItemId portion of a QOrganizerItemMemoryEngineLocalId.
@@ -184,13 +185,13 @@ public:
 
     virtual QList<QOrganizerItem> itemOccurrences(const QOrganizerItem& parentItem, const QDateTime& periodStart, const QDateTime& periodEnd, int maxCount, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
 
-    virtual QList<QOrganizerItemLocalId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const;
+    virtual QList<QOrganizerItemId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const;
     virtual QList<QOrganizerItem> items(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
     virtual QList<QOrganizerItem> itemsForExport(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
-    virtual QOrganizerItem item(const QOrganizerItemLocalId& organizeritemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
+    virtual QOrganizerItem item(const QOrganizerItemId& organizeritemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
 
     virtual bool saveItems(QList<QOrganizerItem>* organizeritems, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
-    virtual bool removeItems(const QList<QOrganizerItemLocalId>& organizeritemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
+    virtual bool removeItems(const QList<QOrganizerItemId>& organizeritemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
 
     virtual QOrganizerCollection defaultCollection(QOrganizerManager::Error* error) const;
     virtual QOrganizerCollection collection(const QOrganizerCollectionLocalId &collectionId, QOrganizerManager::Error *error) const;
@@ -261,7 +262,7 @@ private:
     bool saveItem(QOrganizerItem* theOrganizerItem, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error);
     bool fixOccurrenceReferences(QOrganizerItem* item, QOrganizerManager::Error* error);
     bool typesAreRelated(const QString& occurrenceType, const QString& parentType);
-    bool removeItem(const QOrganizerItemLocalId& organizeritemId, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error);
+    bool removeItem(const QOrganizerItemId& organizeritemId, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error);
     bool saveDetailDefinition(const QOrganizerItemDetailDefinition& def, const QString& organizeritemType, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error);
     bool removeDetailDefinition(const QString& definitionId, const QString& organizeritemType, QOrganizerItemChangeSet& changeSet, QOrganizerManager::Error* error);
 
diff --git a/src/organizer/filters/filters.pri b/src/organizer/filters/filters.pri
index e4b66574b7..86d3ff5fa7 100644
--- a/src/organizer/filters/filters.pri
+++ b/src/organizer/filters/filters.pri
@@ -7,7 +7,7 @@ PUBLIC_HEADERS += filters/qorganizeritemfilters.h \
     filters/qorganizeritemdetailrangefilter.h \
     filters/qorganizeritemintersectionfilter.h \
     filters/qorganizeriteminvalidfilter.h \
-    filters/qorganizeritemlocalidfilter.h \
+    filters/qorganizeritemidfilter.h \
     filters/qorganizeritemcollectionfilter.h \
     filters/qorganizeritemunionfilter.h
 PRIVATE_HEADERS += \
@@ -15,7 +15,7 @@ PRIVATE_HEADERS += \
     filters/qorganizeritemdetailfilter_p.h \
     filters/qorganizeritemdetailrangefilter_p.h \
     filters/qorganizeritemintersectionfilter_p.h \
-    filters/qorganizeritemlocalidfilter_p.h \
+    filters/qorganizeritemidfilter_p.h \
     filters/qorganizeritemcollectionfilter_p.h \
     filters/qorganizeritemunionfilter_p.h
 SOURCES += \
@@ -24,6 +24,6 @@ SOURCES += \
     filters/qorganizeritemdetailrangefilter.cpp \
     filters/qorganizeritemintersectionfilter.cpp \
     filters/qorganizeriteminvalidfilter.cpp \
-    filters/qorganizeritemlocalidfilter.cpp \
+    filters/qorganizeritemidfilter.cpp \
     filters/qorganizeritemcollectionfilter.cpp \
     filters/qorganizeritemunionfilter.cpp
diff --git a/src/organizer/filters/qorganizeritemfilters.h b/src/organizer/filters/qorganizeritemfilters.h
index 114f158052..081504c6fa 100644
--- a/src/organizer/filters/qorganizeritemfilters.h
+++ b/src/organizer/filters/qorganizeritemfilters.h
@@ -51,6 +51,6 @@
 #include "qorganizeritemdetailrangefilter.h"
 #include "qorganizeritemintersectionfilter.h"
 #include "qorganizeriteminvalidfilter.h"
-#include "qorganizeritemlocalidfilter.h"
+#include "qorganizeritemidfilter.h"
 #include "qorganizeritemcollectionfilter.h"
 #endif
diff --git a/src/organizer/filters/qorganizeritemlocalidfilter.cpp b/src/organizer/filters/qorganizeritemidfilter.cpp
index e156922023..ecd740a1d0 100644
--- a/src/organizer/filters/qorganizeritemlocalidfilter.cpp
+++ b/src/organizer/filters/qorganizeritemidfilter.cpp
@@ -39,36 +39,36 @@
 **
 ****************************************************************************/
 
-#include "qorganizeritemlocalidfilter.h"
-#include "qorganizeritemlocalidfilter_p.h"
+#include "qorganizeritemidfilter.h"
+#include "qorganizeritemidfilter_p.h"
 #include "qorganizeritemfilter_p.h"
 #include "qorganizermanager.h"
 
 QTM_BEGIN_NAMESPACE
 
 /*!
-  \class QOrganizerItemLocalIdFilter
-  \brief The QOrganizerItemLocalIdFilter class provides a filter based around a list of organizer item ids
+  \class QOrganizerItemIdFilter
+  \brief The QOrganizerItemIdFilter class provides a filter based around a list of organizer item ids
   \inmodule QtOrganizer
   \ingroup organizer-filters
   
   It may be used to select organizer items whose ids are contained in the given list of ids.
 
-  Note: a QOrganizerItemLocalIdFilter will not be preserved if streamed to a QDataStream.
+  Note: a QOrganizerItemIdFilter will not be preserved if streamed to a QDataStream.
  */
 
-Q_IMPLEMENT_ORGANIZERITEMFILTER_PRIVATE(QOrganizerItemLocalIdFilter);
+Q_IMPLEMENT_ORGANIZERITEMFILTER_PRIVATE(QOrganizerItemIdFilter);
 
 /*!
- * \fn QOrganizerItemLocalIdFilter::QOrganizerItemLocalIdFilter(const QOrganizerItemFilter& other)
+ * \fn QOrganizerItemIdFilter::QOrganizerItemIdFilter(const QOrganizerItemFilter& other)
  * Constructs a copy of \a other if possible, otherwise constructs a new organizer item local id filter
  */
 
 /*!
  * Constructs a new organizer item local id filter
  */
-QOrganizerItemLocalIdFilter::QOrganizerItemLocalIdFilter()
-    : QOrganizerItemFilter(new QOrganizerItemLocalIdFilterPrivate)
+QOrganizerItemIdFilter::QOrganizerItemIdFilter()
+    : QOrganizerItemFilter(new QOrganizerItemIdFilterPrivate)
 {
 }
 
@@ -76,9 +76,9 @@ QOrganizerItemLocalIdFilter::QOrganizerItemLocalIdFilter()
  * Sets the list which contains the ids of possible matching organizer items to \a ids
  * \sa ids()
  */
-void QOrganizerItemLocalIdFilter::setIds(const QList<QOrganizerItemLocalId>& ids)
+void QOrganizerItemIdFilter::setIds(const QList<QOrganizerItemId>& ids)
 {
-    Q_D(QOrganizerItemLocalIdFilter);
+    Q_D(QOrganizerItemIdFilter);
     d->m_ids = ids;
 }
 
@@ -86,9 +86,9 @@ void QOrganizerItemLocalIdFilter::setIds(const QList<QOrganizerItemLocalId>& ids
  * Inserts the id \a id into the list which contains the ids of possible matching items
  * \sa setIds()
  */
-void QOrganizerItemLocalIdFilter::insert(const QOrganizerItemLocalId& id)
+void QOrganizerItemIdFilter::insert(const QOrganizerItemId& id)
 {
-    Q_D(QOrganizerItemLocalIdFilter);
+    Q_D(QOrganizerItemIdFilter);
     if (!d->m_ids.contains(id))
         d->m_ids.append(id);
 }
@@ -98,9 +98,9 @@ void QOrganizerItemLocalIdFilter::insert(const QOrganizerItemLocalId& id)
  * if it is contained in the list, otherwise has no effect.
  * \sa clear()
  */
-void QOrganizerItemLocalIdFilter::remove(const QOrganizerItemLocalId& id)
+void QOrganizerItemIdFilter::remove(const QOrganizerItemId& id)
 {
-    Q_D(QOrganizerItemLocalIdFilter);
+    Q_D(QOrganizerItemIdFilter);
     d->m_ids.removeAll(id);
 }
 
@@ -109,9 +109,9 @@ void QOrganizerItemLocalIdFilter::remove(const QOrganizerItemLocalId& id)
  * A local id filter with a cleared list will match no items.
  * \sa setIds()
  */
-void QOrganizerItemLocalIdFilter::clear()
+void QOrganizerItemIdFilter::clear()
 {
-    Q_D(QOrganizerItemLocalIdFilter);
+    Q_D(QOrganizerItemIdFilter);
     d->m_ids.clear();
 }
 
@@ -119,9 +119,9 @@ void QOrganizerItemLocalIdFilter::clear()
  * Returns the list of ids of organizer items which match this filter
  * \sa setIds()
  */
-QList<QOrganizerItemLocalId> QOrganizerItemLocalIdFilter::ids() const
+QList<QOrganizerItemId> QOrganizerItemIdFilter::ids() const
 {
-    Q_D(const QOrganizerItemLocalIdFilter);
+    Q_D(const QOrganizerItemIdFilter);
     return d->m_ids;
 }
 
diff --git a/src/organizer/filters/qorganizeritemlocalidfilter.h b/src/organizer/filters/qorganizeritemidfilter.h
index 6937c2b1ab..fe213ff4b1 100644
--- a/src/organizer/filters/qorganizeritemlocalidfilter.h
+++ b/src/organizer/filters/qorganizeritemidfilter.h
@@ -39,32 +39,32 @@
 **
 ****************************************************************************/
 
-#ifndef QORGANIZERITEMLOCALIDFILTER_H
-#define QORGANIZERITEMLOCALIDFILTER_H
+#ifndef QORGANIZERITEMIDFILTER_H
+#define QORGANIZERITEMIDFILTER_H
 
 #include "qorganizeritemfilter.h"
 #include "qorganizeritemid.h"
 
 QTM_BEGIN_NAMESPACE
 
-class QOrganizerItemLocalIdFilterPrivate;
-class Q_ORGANIZER_EXPORT QOrganizerItemLocalIdFilter : public QOrganizerItemFilter
+class QOrganizerItemIdFilterPrivate;
+class Q_ORGANIZER_EXPORT QOrganizerItemIdFilter : public QOrganizerItemFilter
 {
 public:
-    QOrganizerItemLocalIdFilter();
-    QOrganizerItemLocalIdFilter(const QOrganizerItemFilter& other);
+    QOrganizerItemIdFilter();
+    QOrganizerItemIdFilter(const QOrganizerItemFilter& other);
 
     /* Mutators */
-    void setIds(const QList<QOrganizerItemLocalId>& ids);
-    void insert(const QOrganizerItemLocalId& id);
-    void remove(const QOrganizerItemLocalId& id);
+    void setIds(const QList<QOrganizerItemId>& ids);
+    void insert(const QOrganizerItemId& id);
+    void remove(const QOrganizerItemId& id);
     void clear();
 
     /* Accessors */
-    QList<QOrganizerItemLocalId> ids() const;
+    QList<QOrganizerItemId> ids() const;
 
 private:
-    Q_DECLARE_ORGANIZERITEMFILTER_PRIVATE(QOrganizerItemLocalIdFilter)
+    Q_DECLARE_ORGANIZERITEMFILTER_PRIVATE(QOrganizerItemIdFilter)
 };
 
 QTM_END_NAMESPACE
diff --git a/src/organizer/filters/qorganizeritemlocalidfilter_p.h b/src/organizer/filters/qorganizeritemidfilter_p.h
index e09e4f0127..e46244d7f8 100644
--- a/src/organizer/filters/qorganizeritemlocalidfilter_p.h
+++ b/src/organizer/filters/qorganizeritemidfilter_p.h
@@ -62,15 +62,15 @@
 
 QTM_BEGIN_NAMESPACE
 
-class QOrganizerItemLocalIdFilterPrivate : public QOrganizerItemFilterPrivate
+class QOrganizerItemIdFilterPrivate : public QOrganizerItemFilterPrivate
 {
 public:
-    QOrganizerItemLocalIdFilterPrivate()
+    QOrganizerItemIdFilterPrivate()
         : QOrganizerItemFilterPrivate()
     {
     }
 
-    QOrganizerItemLocalIdFilterPrivate(const QOrganizerItemLocalIdFilterPrivate& other)
+    QOrganizerItemIdFilterPrivate(const QOrganizerItemIdFilterPrivate& other)
         : QOrganizerItemFilterPrivate(other),
         m_ids(other.m_ids)
     {
@@ -78,7 +78,7 @@ public:
 
     virtual bool compare(const QOrganizerItemFilterPrivate* other) const
     {
-        const QOrganizerItemLocalIdFilterPrivate *od = static_cast<const QOrganizerItemLocalIdFilterPrivate*>(other);
+        const QOrganizerItemIdFilterPrivate *od = static_cast<const QOrganizerItemIdFilterPrivate*>(other);
         if (m_ids != od->m_ids)
             return false;
         return true;
@@ -98,9 +98,9 @@ public:
         return stream;
     }
 
-    Q_IMPLEMENT_ORGANIZERITEMFILTER_VIRTUALCTORS(QOrganizerItemLocalIdFilter, QOrganizerItemFilter::LocalIdFilter)
+    Q_IMPLEMENT_ORGANIZERITEMFILTER_VIRTUALCTORS(QOrganizerItemIdFilter, QOrganizerItemFilter::LocalIdFilter)
 
-    QList<QOrganizerItemLocalId> m_ids;
+    QList<QOrganizerItemId> m_ids;
 };
 
 QTM_END_NAMESPACE
diff --git a/src/organizer/items/qorganizereventoccurrence.cpp b/src/organizer/items/qorganizereventoccurrence.cpp
index 1d3426409b..5dca93f1a7 100644
--- a/src/organizer/items/qorganizereventoccurrence.cpp
+++ b/src/organizer/items/qorganizereventoccurrence.cpp
@@ -99,22 +99,22 @@ QDateTime QOrganizerEventOccurrence::endDateTime() const
 
 /*!
   Sets the event occurrence's parent to be the event identified by the
-  given \a parentLocalId
+  given \a parentId
  */
-void QOrganizerEventOccurrence::setParentLocalId(const QOrganizerItemLocalId& parentLocalId)
+void QOrganizerEventOccurrence::setParentId(const QOrganizerItemId& parentId)
 {
     QOrganizerItemParent origin = detail<QOrganizerItemParent>();
-    origin.setParentLocalId(parentLocalId);
+    origin.setParentId(parentId);
     saveDetail(&origin);
 }
 
 /*!
   Returns the local id of the event which is this occurrence's parent
  */
-QOrganizerItemLocalId QOrganizerEventOccurrence::parentLocalId() const
+QOrganizerItemId QOrganizerEventOccurrence::parentId() const
 {
     QOrganizerItemParent origin = detail<QOrganizerItemParent>();
-    return origin.parentLocalId();
+    return origin.parentId();
 }
 
 /*!
diff --git a/src/organizer/items/qorganizereventoccurrence.h b/src/organizer/items/qorganizereventoccurrence.h
index 42bccbba89..79024c5841 100644
--- a/src/organizer/items/qorganizereventoccurrence.h
+++ b/src/organizer/items/qorganizereventoccurrence.h
@@ -59,8 +59,8 @@ public:
     void setEndDateTime(const QDateTime& endDateTime);
     QDateTime endDateTime() const;
 
-    void setParentLocalId(const QOrganizerItemLocalId& parentId);
-    QOrganizerItemLocalId parentLocalId() const;
+    void setParentId(const QOrganizerItemId& parentId);
+    QOrganizerItemId parentId() const;
     void setOriginalDate(const QDate& date);
     QDate originalDate() const;
 
diff --git a/src/organizer/items/qorganizertodooccurrence.cpp b/src/organizer/items/qorganizertodooccurrence.cpp
index 0de1a7296b..8dd8b2e1c4 100644
--- a/src/organizer/items/qorganizertodooccurrence.cpp
+++ b/src/organizer/items/qorganizertodooccurrence.cpp
@@ -99,22 +99,22 @@ QDateTime QOrganizerTodoOccurrence::dueDateTime() const
 
 /*!
   Sets the todo occurrence's parent to be the todo identified by the
-  given \a parentLocalId
+  given \a parentId
  */
-void QOrganizerTodoOccurrence::setParentLocalId(const QOrganizerItemLocalId& parentLocalId)
+void QOrganizerTodoOccurrence::setParentId(const QOrganizerItemId& parentId)
 {
     QOrganizerItemParent origin = detail<QOrganizerItemParent>();
-    origin.setParentLocalId(parentLocalId);
+    origin.setParentId(parentId);
     saveDetail(&origin);
 }
 
 /*!
   Returns the local id of the todo which is this occurrence's parent
  */
-QOrganizerItemLocalId QOrganizerTodoOccurrence::parentLocalId() const
+QOrganizerItemId QOrganizerTodoOccurrence::parentId() const
 {
     QOrganizerItemParent origin = detail<QOrganizerItemParent>();
-    return origin.parentLocalId();
+    return origin.parentId();
 }
 
 /*!
diff --git a/src/organizer/items/qorganizertodooccurrence.h b/src/organizer/items/qorganizertodooccurrence.h
index c4c2f40fde..38bb1834bb 100644
--- a/src/organizer/items/qorganizertodooccurrence.h
+++ b/src/organizer/items/qorganizertodooccurrence.h
@@ -60,8 +60,8 @@ public:
     void setDueDateTime(const QDateTime& dueDateTime);
     QDateTime dueDateTime() const;
 
-    void setParentLocalId(const QOrganizerItemLocalId& parentId);
-    QOrganizerItemLocalId parentLocalId() const;
+    void setParentId(const QOrganizerItemId& parentId);
+    QOrganizerItemId parentId() const;
     void setOriginalDate(const QDate& date);
     QDate originalDate() const;
 
diff --git a/src/organizer/qorganizeritem.cpp b/src/organizer/qorganizeritem.cpp
index 4df0d23cf2..ff1628084b 100644
--- a/src/organizer/qorganizeritem.cpp
+++ b/src/organizer/qorganizeritem.cpp
@@ -265,25 +265,6 @@ QOrganizerItemId QOrganizerItem::id() const
 }
 
 /*!
-    Returns the QOrganizerItemLocalId that identifies this organizer item within its manager
-
-    This may have been set when the organizer item was retrieved from
-    a particular manager, or when the organizer item was first saved
-    in a manager.  The QOrganizerItemLocalId is associated with a specific
-    manager, but other organizer items with the same local id might exist in
-    different managers.
-
-    See \l QOrganizerManager::saveItem() for more
-    information.
-
-   \sa id()
-*/
-QOrganizerItemLocalId QOrganizerItem::localId() const
-{
-    return d->m_id.localId();
-}
-
-/*!
   Returns the id of the collection which this item is part of, in the manager
   in which the item has been saved, if the item has previously been saved in
   a manager.  If the item has not previously been saved in a manager, this function
diff --git a/src/organizer/qorganizeritem.h b/src/organizer/qorganizeritem.h
index f3bba4d7fe..468dade54a 100644
--- a/src/organizer/qorganizeritem.h
+++ b/src/organizer/qorganizeritem.h
@@ -88,7 +88,6 @@ public:
     /* Unique ID */
     QOrganizerItemId id() const;
     void setId(const QOrganizerItemId& id);
-    QOrganizerItemLocalId localId() const;
 
     /* The collection to which an item belongs - read only */
     QOrganizerCollectionId collectionId() const;
diff --git a/src/organizer/qorganizeritemchangeset.cpp b/src/organizer/qorganizeritemchangeset.cpp
index 8505753ed3..38927ee6ca 100644
--- a/src/organizer/qorganizeritemchangeset.cpp
+++ b/src/organizer/qorganizeritemchangeset.cpp
@@ -117,7 +117,7 @@ bool QOrganizerItemChangeSet::dataChanged()
    Returns the set of ids of organizer items which have been added to
    the database.
  */
-QSet<QOrganizerItemLocalId> QOrganizerItemChangeSet::addedItems() const
+QSet<QOrganizerItemId> QOrganizerItemChangeSet::addedItems() const
 {
     return d->m_addedItems;
 }
@@ -126,7 +126,7 @@ QSet<QOrganizerItemLocalId> QOrganizerItemChangeSet::addedItems() const
   Inserts the given organizer item id \a addedOrganizerItemId into the set of ids of organizer items
   which have been added to the database.
  */
-void QOrganizerItemChangeSet::insertAddedItem(const QOrganizerItemLocalId& addedOrganizerItemId)
+void QOrganizerItemChangeSet::insertAddedItem(const QOrganizerItemId& addedOrganizerItemId)
 {
     d->m_addedItems.insert(addedOrganizerItemId);
 }
@@ -135,9 +135,9 @@ void QOrganizerItemChangeSet::insertAddedItem(const QOrganizerItemLocalId& added
   Inserts each of the given organizer item ids \a addedOrganizerItemIds into the set of ids of organizer items
   which have been added to the database.
  */
-void QOrganizerItemChangeSet::insertAddedItems(const QList<QOrganizerItemLocalId>& addedOrganizerItemIds)
+void QOrganizerItemChangeSet::insertAddedItems(const QList<QOrganizerItemId>& addedOrganizerItemIds)
 {
-    foreach (const QOrganizerItemLocalId& id, addedOrganizerItemIds)
+    foreach (const QOrganizerItemId& id, addedOrganizerItemIds)
         d->m_addedItems.insert(id);
 }
 
@@ -153,7 +153,7 @@ void QOrganizerItemChangeSet::clearAddedItems()
    Returns the set of ids of organizer items which have been changed in
    the database.
  */
-QSet<QOrganizerItemLocalId> QOrganizerItemChangeSet::changedItems() const
+QSet<QOrganizerItemId> QOrganizerItemChangeSet::changedItems() const
 {
     return d->m_changedItems;
 }
@@ -162,7 +162,7 @@ QSet<QOrganizerItemLocalId> QOrganizerItemChangeSet::changedItems() const
   Inserts the given organizer item id \a changedOrganizerItemId into the set of ids of organizer items
   which have been changed to the database.
  */
-void QOrganizerItemChangeSet::insertChangedItem(const QOrganizerItemLocalId& changedOrganizerItemId)
+void QOrganizerItemChangeSet::insertChangedItem(const QOrganizerItemId& changedOrganizerItemId)
 {
     d->m_changedItems.insert(changedOrganizerItemId);
 }
@@ -171,9 +171,9 @@ void QOrganizerItemChangeSet::insertChangedItem(const QOrganizerItemLocalId& cha
   Inserts each of the given organizer item ids \a changedOrganizerItemIds into the set of ids of organizer items
   which have been changed to the database.
  */
-void QOrganizerItemChangeSet::insertChangedItems(const QList<QOrganizerItemLocalId>& changedOrganizerItemIds)
+void QOrganizerItemChangeSet::insertChangedItems(const QList<QOrganizerItemId>& changedOrganizerItemIds)
 {
-    foreach (const QOrganizerItemLocalId& id, changedOrganizerItemIds)
+    foreach (const QOrganizerItemId& id, changedOrganizerItemIds)
         d->m_changedItems.insert(id);
 }
 
@@ -189,7 +189,7 @@ void QOrganizerItemChangeSet::clearChangedItems()
    Returns the set of ids of organizer items which have been removed from
    the database.
  */
-QSet<QOrganizerItemLocalId> QOrganizerItemChangeSet::removedItems() const
+QSet<QOrganizerItemId> QOrganizerItemChangeSet::removedItems() const
 {
     return d->m_removedItems;
 }
@@ -198,7 +198,7 @@ QSet<QOrganizerItemLocalId> QOrganizerItemChangeSet::removedItems() const
   Inserts the given organizer item id \a removedOrganizerItemId into the set of ids of organizer items
   which have been removed to the database.
  */
-void QOrganizerItemChangeSet::insertRemovedItem(const QOrganizerItemLocalId& removedOrganizerItemId)
+void QOrganizerItemChangeSet::insertRemovedItem(const QOrganizerItemId& removedOrganizerItemId)
 {
     d->m_removedItems.insert(removedOrganizerItemId);
 }
@@ -207,9 +207,9 @@ void QOrganizerItemChangeSet::insertRemovedItem(const QOrganizerItemLocalId& rem
   Inserts each of the given organizer item ids \a removedOrganizerItemIds into the set of ids of organizer items
   which have been removed to the database.
  */
-void QOrganizerItemChangeSet::insertRemovedItems(const QList<QOrganizerItemLocalId>& removedOrganizerItemIds)
+void QOrganizerItemChangeSet::insertRemovedItems(const QList<QOrganizerItemId>& removedOrganizerItemIds)
 {
-    foreach (const QOrganizerItemLocalId& id, removedOrganizerItemIds)
+    foreach (const QOrganizerItemId& id, removedOrganizerItemIds)
         d->m_removedItems.insert(id);
 }
 
diff --git a/src/organizer/qorganizeritemchangeset.h b/src/organizer/qorganizeritemchangeset.h
index c0460eb9f6..689cd228fe 100644
--- a/src/organizer/qorganizeritemchangeset.h
+++ b/src/organizer/qorganizeritemchangeset.h
@@ -66,19 +66,19 @@ public:
     void setDataChanged(bool dataChanged);
     bool dataChanged();
 
-    QSet<QOrganizerItemLocalId> addedItems() const;
-    void insertAddedItem(const QOrganizerItemLocalId& addedItemId);
-    void insertAddedItems(const QList<QOrganizerItemLocalId>& addedItemIds);
+    QSet<QOrganizerItemId> addedItems() const;
+    void insertAddedItem(const QOrganizerItemId& addedItemId);
+    void insertAddedItems(const QList<QOrganizerItemId>& addedItemIds);
     void clearAddedItems();
 
-    QSet<QOrganizerItemLocalId> changedItems() const;
-    void insertChangedItem(const QOrganizerItemLocalId& addedItemId);
-    void insertChangedItems(const QList<QOrganizerItemLocalId>& addedItemIds);
+    QSet<QOrganizerItemId> changedItems() const;
+    void insertChangedItem(const QOrganizerItemId& addedItemId);
+    void insertChangedItems(const QList<QOrganizerItemId>& addedItemIds);
     void clearChangedItems();
 
-    QSet<QOrganizerItemLocalId> removedItems() const;
-    void insertRemovedItem(const QOrganizerItemLocalId& addedItemId);
-    void insertRemovedItems(const QList<QOrganizerItemLocalId>& addedItemIds);
+    QSet<QOrganizerItemId> removedItems() const;
+    void insertRemovedItem(const QOrganizerItemId& addedItemId);
+    void insertRemovedItems(const QList<QOrganizerItemId>& addedItemIds);
     void clearRemovedItems();
 
     void clearAll();
diff --git a/src/organizer/qorganizeritemchangeset_p.h b/src/organizer/qorganizeritemchangeset_p.h
index ebe38720a1..e1da784141 100644
--- a/src/organizer/qorganizeritemchangeset_p.h
+++ b/src/organizer/qorganizeritemchangeset_p.h
@@ -84,9 +84,9 @@ public:
     }
 
     bool m_dataChanged;
-    QSet<QOrganizerItemLocalId> m_addedItems;
-    QSet<QOrganizerItemLocalId> m_changedItems;
-    QSet<QOrganizerItemLocalId> m_removedItems;
+    QSet<QOrganizerItemId> m_addedItems;
+    QSet<QOrganizerItemId> m_changedItems;
+    QSet<QOrganizerItemId> m_removedItems;
 };
 
 QTM_END_NAMESPACE
diff --git a/src/organizer/qorganizeritemenginelocalid.cpp b/src/organizer/qorganizeritemenginelocalid.cpp
index 7dfd57e5fe..1c90c6e50f 100644
--- a/src/organizer/qorganizeritemenginelocalid.cpp
+++ b/src/organizer/qorganizeritemenginelocalid.cpp
@@ -43,7 +43,7 @@
 
 /*!
   \class QOrganizerItemEngineLocalId
-  \relates QOrganizerItemLocalId
+  \relates QOrganizerItemId
   \brief The QOrganizerItemEngineLocalId class uniquely identifies an item within a
   particular engine plugin.
 
@@ -65,14 +65,14 @@
   \fn QOrganizerItemEngineLocalId::isEqualTo(const QOrganizerItemEngineLocalId* other) const
   Returns true if this id is equal to the \a other id; false otherwise.
   Note that when implementing this function, you do not have to check that the type is the same,
-  since the function which calls this function (in QOrganizerItemLocalId) does that check for you.
+  since the function which calls this function (in QOrganizerItemId) does that check for you.
  */
 
 /*!
   \fn QOrganizerItemEngineLocalId::isLessThan(const QOrganizerItemEngineLocalId* other) const
   Returns true if this id is less than the \a other id; false otherwise.
   Note that when implementing this function, you do not have to check that the type is the same,
-  since the function which calls this function (in QOrganizerItemLocalId) does that check for you.
+  since the function which calls this function (in QOrganizerItemId) does that check for you.
  */
 
 /*!
diff --git a/src/organizer/qorganizeritemenginelocalid.h b/src/organizer/qorganizeritemenginelocalid.h
index 7c0d84f28a..ad865015e1 100644
--- a/src/organizer/qorganizeritemenginelocalid.h
+++ b/src/organizer/qorganizeritemenginelocalid.h
@@ -60,11 +60,12 @@ public:
     virtual bool isLessThan(const QOrganizerItemEngineLocalId* other) const = 0;
 
     virtual uint engineLocalIdType() const = 0;
+    virtual QString managerUri() const = 0;
     virtual QOrganizerItemEngineLocalId* clone() const = 0;
 
 #ifndef QT_NO_DEBUG_STREAM
     // NOTE: on platforms where Qt is built without debug streams enabled, vtable will differ!
-    virtual QDebug debugStreamOut(QDebug dbg) = 0;
+    virtual QDebug& debugStreamOut(QDebug& dbg) = 0;
 #endif
 #ifndef QT_NO_DATASTREAM
     // NOTE: on platforms where Qt is built without data streams enabled, vtable will differ!
diff --git a/src/organizer/qorganizeritemfilter.cpp b/src/organizer/qorganizeritemfilter.cpp
index 9a7488eba2..2156054219 100644
--- a/src/organizer/qorganizeritemfilter.cpp
+++ b/src/organizer/qorganizeritemfilter.cpp
@@ -157,7 +157,7 @@ bool QOrganizerItemFilter::operator==(const QOrganizerItemFilter& other) const
 /*!
  * Writes \a filter to the stream \a out.
  *
- * A QOrganizerItemLocalIdFilter will not be preserved if streamed to a QDataStream.
+ * A QOrganizerItemIdFilter will not be preserved if streamed to a QDataStream.
  */
 QDataStream& operator<<(QDataStream& out, const QOrganizerItemFilter& filter)
 {
@@ -171,7 +171,7 @@ QDataStream& operator<<(QDataStream& out, const QOrganizerItemFilter& filter)
 /*!
  * Reads an organizer item filter from stream \a in into \a filter.
  *
- * A QOrganizerItemLocalIdFilter will not be preserved if streamed from a QDataStream.
+ * A QOrganizerItemIdFilter will not be preserved if streamed from a QDataStream.
  */
 QDataStream& operator>>(QDataStream& in, QOrganizerItemFilter& filter)
 {
@@ -200,7 +200,7 @@ QDataStream& operator>>(QDataStream& in, QOrganizerItemFilter& filter)
                 filter = QOrganizerItemUnionFilter();
                 break;
             case QOrganizerItemFilter::LocalIdFilter:
-                filter = QOrganizerItemLocalIdFilter();
+                filter = QOrganizerItemIdFilter();
                 break;
             case QOrganizerItemFilter::DefaultFilter:
                 filter = QOrganizerItemFilter();
diff --git a/src/organizer/qorganizeritemid.cpp b/src/organizer/qorganizeritemid.cpp
index 5c48dab81e..54e24fa4ad 100644
--- a/src/organizer/qorganizeritemid.cpp
+++ b/src/organizer/qorganizeritemid.cpp
@@ -40,7 +40,6 @@
 ****************************************************************************/
 
 #include "qorganizeritemid.h"
-#include "qorganizeritemid_p.h"
 #include "qorganizeritemenginelocalid.h"
 #include "qorganizermanager_p.h"
 #include <QHash>
@@ -59,42 +58,15 @@ QTM_BEGIN_NAMESPACE
   It consists of a manager URI which identifies the manager which contains the organizer item,
   and the local id of the organizer item in that manager.
 
-  A "null" QOrganizerItemId has an empty manager URI, and an invalid QOrganizerItemLocalId (0).
-
-  \sa QOrganizerItemLocalId
+  A "null" QOrganizerItemId has an empty manager URI
  */
 
 /*!
-  \class QOrganizerItemLocalId
-  \relates QOrganizerItemId
-  \brief The QOrganizerItemLocalId class represents the unique id of an organizer item within its manager.
-
-  Most operations within a \l QOrganizerManager accept a QOrganizerItemLocalId.  Some operations
-  (involving links to organizer items outside a particular manager) also accept a manager URI - this
-  combination is stored in a \l QOrganizerItemId.
-
-  A default-constructed QOrganizerItemLocalId is a null QOrganizerItemLocalId, which does not identify
-  any item in a manager.  Clients may wish to set the local id of an item to the default-constructed id
-  if they wish to copy that item from one manager to another (by calling QOrganizerManager::saveItem()),
-  whereupon that manager will replace the id with one that identifies the newly created item.
-
-  \sa QOrganizerItemId
-*/
-
-/*!
-  Constructs a new, null QOrganizerItemLocalId.
- */
-QOrganizerItemLocalId::QOrganizerItemLocalId()
-    : d(0)
-{
-}
-
-/*!
-  Cleans up any memory in use by this local id.
+ * Constructs a new organizer item id
  */
-QOrganizerItemLocalId::~QOrganizerItemLocalId()
+QOrganizerItemId::QOrganizerItemId()
+        : d(0)
 {
-    delete d;
 }
 
 /*!
@@ -103,15 +75,21 @@ QOrganizerItemLocalId::~QOrganizerItemLocalId()
   will delete it when the local id goes out of scope.  Engine implementors must not
   delete the \a engineItemId or undefined behaviour will occur.
  */
-QOrganizerItemLocalId::QOrganizerItemLocalId(QOrganizerItemEngineLocalId* engineItemId)
+QOrganizerItemId::QOrganizerItemId(QOrganizerItemEngineLocalId* engineItemId)
     : d(engineItemId)
 {
 }
 
 /*!
-  Constructs a new copy of the \a other id.
+ * Cleans up the memory in use by the organizer item id
  */
-QOrganizerItemLocalId::QOrganizerItemLocalId(const QOrganizerItemLocalId& other)
+QOrganizerItemId::~QOrganizerItemId()
+{
+    delete d;
+}
+
+/*! Constructs a new organizer item id as a copy of \a other */
+QOrganizerItemId::QOrganizerItemId(const QOrganizerItemId& other)
 {
     if (other.d)
         d = other.d->clone();
@@ -119,10 +97,8 @@ QOrganizerItemLocalId::QOrganizerItemLocalId(const QOrganizerItemLocalId& other)
         d = 0;
 }
 
-/*!
-  Assigns the \a other id to this id.
- */
-QOrganizerItemLocalId& QOrganizerItemLocalId::operator=(const QOrganizerItemLocalId& other)
+/*! Assigns the organizer item id to be equal to \a other */
+QOrganizerItemId& QOrganizerItemId::operator=(const QOrganizerItemId& other)
 {
     if (d == other.d)
         return *this;
@@ -139,10 +115,8 @@ QOrganizerItemLocalId& QOrganizerItemLocalId::operator=(const QOrganizerItemLoca
     return *this;
 }
 
-/*!
-  Returns true if this id is equal to the \a other id; otherwise returns false.
- */
-bool QOrganizerItemLocalId::operator==(const QOrganizerItemLocalId& other) const
+/*! Returns true if the organizer item id has the same manager URI and local id as \a other */
+bool QOrganizerItemId::operator==(const QOrganizerItemId& other) const
 {
     // if both ids are null then they are equal.
     if (d == 0 && other.d == 0)
@@ -157,79 +131,6 @@ bool QOrganizerItemLocalId::operator==(const QOrganizerItemLocalId& other) const
     return false;
 }
 
-/*!
-  Returns true if this id is not equal to the \a other id; otherwise, returns false.
- */
-bool QOrganizerItemLocalId::operator!=(const QOrganizerItemLocalId& other) const
-{
-    return !(*this == other);
-}
-
-/*!
-  Returns true if this id is less than the \a other id; otherwise, returns false.
- */
-bool QOrganizerItemLocalId::operator<(const QOrganizerItemLocalId& other) const
-{
-    // a null id is always less than a non-null id.
-    if (d == 0 && other.d != 0)
-        return true;
-
-    if (d && other.d) {
-        // ensure they're of the same type (and therefore comparable)
-        if (d->engineLocalIdType() == other.d->engineLocalIdType()) {
-            return d->isLessThan(other.d);
-        }
-    }
-
-    return false;
-}
-
-/*!
-  Returns true if this id is a null or default constructed id; otherwise, returns false.
- */
-bool QOrganizerItemLocalId::isNull() const
-{
-    return (d == 0);
-}
-
-/*!
- * Constructs a new organizer item id
- */
-QOrganizerItemId::QOrganizerItemId()
-        : d(new QOrganizerItemIdPrivate)
-{
-}
-
-/*!
- * Cleans up the memory in use by the organizer item id
- */
-QOrganizerItemId::~QOrganizerItemId()
-{
-}
-
-/*! Constructs a new organizer item id as a copy of \a other */
-QOrganizerItemId::QOrganizerItemId(const QOrganizerItemId& other)
-        : d(other.d)
-{
-}
-
-/*! Assigns the organizer item id to be equal to \a other */
-QOrganizerItemId& QOrganizerItemId::operator=(const QOrganizerItemId& other)
-{
-    d = other.d;
-    return *this;
-}
-
-/*! Returns true if the organizer item id has the same manager URI and local id as \a other */
-bool QOrganizerItemId::operator==(const QOrganizerItemId& other) const
-{
-    if (d && other.d)
-        return (d->m_managerUri == other.d->m_managerUri) &&
-               (d->m_localId == other.d->m_localId);
-
-    return !d && !other.d;
-}
-
 /*! Returns true if either the manager URI or local id of the organizer item id is different to that of \a other */
 bool QOrganizerItemId::operator!=(const QOrganizerItemId& other) const
 {
@@ -252,62 +153,43 @@ bool QOrganizerItemId::operator!=(const QOrganizerItemId& other) const
  */
 bool QOrganizerItemId::operator<(const QOrganizerItemId& other) const
 {
-    const int comp = this->managerUri().compare(other.managerUri());
-    if (comp != 0)
-        return comp < 0;
+    // a null id is always less than a non-null id.
+    if (d == 0 && other.d != 0)
+        return true;
 
-    return this->localId() < other.localId();
+    if (d && other.d) {
+        // ensure they're of the same type (and therefore comparable)
+        if (d->engineLocalIdType() == other.d->engineLocalIdType()) {
+            return d->isLessThan(other.d);
+        }
+    }
+
+    return false;
 }
 
 /*!
  * Returns the hash value for \a key.
  */
-uint qHash(const QOrganizerItemLocalId &key)
+uint qHash(const QOrganizerItemId &key)
 {
     if (key.d)
         return QT_PREPEND_NAMESPACE(qHash)(key.d->hash());
     return 0;
 }
 
-/*!
- * Returns the hash value for \a key.
- */
-uint qHash(const QOrganizerItemId &key)
-{
-    return QT_PREPEND_NAMESPACE(qHash)(key.managerUri())
-            + qHash(key.localId());
-}
-
 #ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug dbg, const QOrganizerItemLocalId& id)
+QDebug& operator<<(QDebug& dbg, const QOrganizerItemId& id)
 {
-    if (id.d) {
-        return id.d->debugStreamOut(dbg);
-    }
-
-    dbg << QString(QLatin1String("(null)")); // no local id data.
-    return dbg;
-}
-
-QDebug operator<<(QDebug dbg, const QOrganizerItemId& id)
-{
-    dbg.nospace() << "QOrganizerItemId(" << id.managerUri() << ", " << id.localId() << ")";
+    dbg.nospace() << "QOrganizerItemId(";
+    if (id.isNull())
+        dbg.nospace() << "(null))";
+    else
+        id.d->debugStreamOut(dbg)  << ")";
     return dbg.maybeSpace();
 }
 #endif
 
 #ifndef QT_NO_DATASTREAM
-QDataStream& operator<<(QDataStream& out, const QOrganizerItemLocalId& id)
-{
-    if (id.d) {
-        // we include a marker which contains "true" if there is local id data to be streamed.
-        out << static_cast<quint8>(true);
-        return id.d->dataStreamOut(out);
-    }
-
-    out << static_cast<quint8>(false);
-    return out;
-}
 
 /*!
  * Writes \a id to the stream \a out.
@@ -321,13 +203,10 @@ QDataStream& operator<<(QDataStream& out, const QOrganizerItemId& id)
     out << formatVersion
         << id.managerUri();
 
-    // if the manager uri is null, there'd be no way to deserialize
-    // the local id.  So, we don't serialize out the local id.
-    if (id.managerUri().isEmpty())
-        return out;
+    // the id is not null. we can serialize out
+    if (!id.isNull())
+        out << id.d->dataStreamOut(out);
 
-    // the manager uri is not null.  we can serialize out the local id.
-    out << id.localId();
     return out;
 }
 
@@ -352,23 +231,15 @@ QDataStream& operator>>(QDataStream& in, QOrganizerItemId& id)
         }
         quint8 localIdMarker = static_cast<quint8>(false);
         in >> localIdMarker;
-        QOrganizerItemLocalId localId(QOrganizerManagerData::createEngineItemLocalId(managerUri));
-        if (localIdMarker == static_cast<quint8>(true)) {
-            if (localId.d) {
-                // only try to stream in data if it exists and the engine could create an engine
-                // specific localId based on the managerUri. otherwise, skip it.
-                localId.d->dataStreamIn(in);
-            } else {
-                // the local id should be the null local id
-                localId = QOrganizerItemLocalId();
-            }
+        QOrganizerItemId id(QOrganizerManagerData::createEngineItemId(managerUri));
+        if (id.d) {
+            // only try to stream in data if it exists and the engine could create an engine
+            // specific id based on the managerUri. otherwise, skip it.
+            id.d->dataStreamIn(in);
         } else {
-            // the local id should be the null local id
-            localId = QOrganizerItemLocalId();
+            // the id should be the null id
+            id = QOrganizerItemId();
         }
-
-        id.setManagerUri(managerUri);
-        id.setLocalId(localId);
     } else {
         in.setStatus(QDataStream::ReadCorruptData);
     }
@@ -381,7 +252,7 @@ QDataStream& operator>>(QDataStream& in, QOrganizerItemId& id)
  */
 bool QOrganizerItemId::isNull() const
 {
-    return d->m_localId.isNull();
+    return d == 0;
 }
 
 /*!
@@ -389,35 +260,7 @@ bool QOrganizerItemId::isNull() const
  */
 QString QOrganizerItemId::managerUri() const
 {
-    return d->m_managerUri;
-}
-
-/*!
- * Returns the manager-local id of the organizer item identified by this organizer item id
- */
-QOrganizerItemLocalId QOrganizerItemId::localId() const
-{
-    return d->m_localId;
-}
-
-/*!
- * Sets the URI of the manager which contains the organizer item identified by this id to \a uri.
- * If the old manager URI was different to \a uri, the local id will be set to the null local id.
- * \sa localId()
- */
-void QOrganizerItemId::setManagerUri(const QString& uri)
-{
-    if (!d->m_managerUri.isEmpty() && d->m_managerUri != uri)
-        d->m_localId = QOrganizerItemLocalId();
-    d->m_managerUri = uri;
-}
-
-/*!
- * Sets the manager-local id of the organizer item identified by this organizer item id to \a id
- */
-void QOrganizerItemId::setLocalId(const QOrganizerItemLocalId& id)
-{
-    d->m_localId = id;
+    return d ? d->managerUri() : QString();
 }
 
 QTM_END_NAMESPACE
diff --git a/src/organizer/qorganizeritemid.h b/src/organizer/qorganizeritemid.h
index 7e2272715c..927be01ff0 100644
--- a/src/organizer/qorganizeritemid.h
+++ b/src/organizer/qorganizeritemid.h
@@ -52,16 +52,12 @@ class QDataStream;
 QTM_BEGIN_NAMESPACE
 
 // MSVC needs the function declared before the friend declaration
-class QOrganizerItemLocalId;
 class QOrganizerItemId;
-Q_ORGANIZER_EXPORT uint qHash(const QOrganizerItemLocalId& key);
 Q_ORGANIZER_EXPORT uint qHash(const QOrganizerItemId& key);
 #ifndef QT_NO_DEBUG_STREAM
-Q_ORGANIZER_EXPORT QDebug operator<<(QDebug dbg, const QOrganizerItemLocalId& id);
-Q_ORGANIZER_EXPORT QDebug operator<<(QDebug dbg, const QOrganizerItemId& id);
+Q_ORGANIZER_EXPORT QDebug& operator<<(QDebug& dbg, const QOrganizerItemId& id);
 #endif
 #ifndef QT_NO_DATASTREAM
-Q_ORGANIZER_EXPORT QDataStream& operator<<(QDataStream& out, const QOrganizerItemLocalId& id);
 Q_ORGANIZER_EXPORT QDataStream& operator<<(QDataStream& out, const QOrganizerItemId& id);
 Q_ORGANIZER_EXPORT QDataStream& operator>>(QDataStream& in, QOrganizerItemId& id);
 #endif
@@ -69,43 +65,11 @@ Q_ORGANIZER_EXPORT QDataStream& operator>>(QDataStream& in, QOrganizerItemId& id
 class QOrganizerManagerEngine;
 class QOrganizerItemEngineLocalId;
 
-class QOrganizerItemId;
-class Q_ORGANIZER_EXPORT QOrganizerItemLocalId
-{
-public:
-    QOrganizerItemLocalId();
-    explicit QOrganizerItemLocalId(QOrganizerItemEngineLocalId* engineId);
-
-    ~QOrganizerItemLocalId();
-
-    QOrganizerItemLocalId(const QOrganizerItemLocalId& other);
-    QOrganizerItemLocalId& operator=(const QOrganizerItemLocalId& other);
-
-    bool operator==(const QOrganizerItemLocalId& other) const;
-    bool operator!=(const QOrganizerItemLocalId& other) const;
-    bool operator<(const QOrganizerItemLocalId& other) const;
-
-    bool isNull() const;
-
-private:
-    QOrganizerItemEngineLocalId* d;
-
-#ifndef QT_NO_DEBUG_STREAM
-    Q_ORGANIZER_EXPORT friend QDebug operator<<(QDebug dbg, const QOrganizerItemLocalId& id);
-#endif
-#ifndef QT_NO_DATASTREAM
-    Q_ORGANIZER_EXPORT friend QDataStream& operator<<(QDataStream& out, const QOrganizerItemLocalId& id);
-    Q_ORGANIZER_EXPORT friend QDataStream& operator>>(QDataStream& in, QOrganizerItemId& id);
-#endif
-    Q_ORGANIZER_EXPORT friend uint qHash(const QOrganizerItemLocalId& key);
-    friend class QOrganizerManagerEngine;
-};
-
-class QOrganizerItemIdPrivate;
 class Q_ORGANIZER_EXPORT QOrganizerItemId
 {
 public:
     QOrganizerItemId();
+    explicit QOrganizerItemId(QOrganizerItemEngineLocalId* engineId);
     ~QOrganizerItemId();
 
     QOrganizerItemId(const QOrganizerItemId& other);
@@ -118,21 +82,24 @@ public:
     bool isNull() const;
 
     QString managerUri() const;
-    QOrganizerItemLocalId localId() const;
-
-    void setManagerUri(const QString& uri);
-    void setLocalId(const QOrganizerItemLocalId& id);
 
 private:
-    QSharedDataPointer<QOrganizerItemIdPrivate> d;
+    QOrganizerItemEngineLocalId *d;
+
+#ifndef QT_NO_DEBUG_STREAM
+    Q_ORGANIZER_EXPORT friend QDebug& operator<<(QDebug& dbg, const QOrganizerItemId& id);
+#endif
+#ifndef QT_NO_DATASTREAM
+    Q_ORGANIZER_EXPORT friend QDataStream& operator<<(QDataStream& out, const QOrganizerItemId& id);
+    Q_ORGANIZER_EXPORT friend QDataStream& operator>>(QDataStream& in, QOrganizerItemId& id);
+#endif
+    Q_ORGANIZER_EXPORT friend uint qHash(const QOrganizerItemId& key);
+    friend class QOrganizerManagerEngine;
 };
 
 QTM_END_NAMESPACE
 
-Q_DECLARE_TYPEINFO(QTM_PREPEND_NAMESPACE(QOrganizerItemLocalId), Q_MOVABLE_TYPE);
 Q_DECLARE_TYPEINFO(QTM_PREPEND_NAMESPACE(QOrganizerItemId), Q_MOVABLE_TYPE);
-
-Q_DECLARE_METATYPE(QTM_PREPEND_NAMESPACE(QOrganizerItemLocalId))
 Q_DECLARE_METATYPE(QTM_PREPEND_NAMESPACE(QOrganizerItemId))
 
 
diff --git a/src/organizer/qorganizeritemid_p.h b/src/organizer/qorganizeritemid_p.h
deleted file mode 100644
index f4e6385070..0000000000
--- a/src/organizer/qorganizeritemid_p.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Qt Mobility Components.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights.  These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QORGANIZERITEMID_P_H
-#define QORGANIZERITEMID_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Qt API.  It exists purely as an
-// implementation detail.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QString>
-#include <QSharedData>
-
-#include "qorganizeritemid.h"
-
-QTM_BEGIN_NAMESPACE
-
-class QOrganizerItemIdPrivate : public QSharedData
-{
-public:
-    QOrganizerItemIdPrivate()
-            : QSharedData()
-    {
-    }
-
-    QOrganizerItemIdPrivate(const QOrganizerItemIdPrivate& other)
-            : QSharedData(other),
-            m_managerUri(other.m_managerUri),
-            m_localId(other.m_localId)
-    {
-    }
-
-    ~QOrganizerItemIdPrivate()
-    {
-    }
-
-    QString m_managerUri;
-    QOrganizerItemLocalId m_localId;
-};
-
-QTM_END_NAMESPACE
-
-#endif
diff --git a/src/organizer/qorganizermanager.cpp b/src/organizer/qorganizermanager.cpp
index eef4d0e3cc..164f836184 100644
--- a/src/organizer/qorganizermanager.cpp
+++ b/src/organizer/qorganizermanager.cpp
@@ -80,19 +80,19 @@ QTM_BEGIN_NAMESPACE
  */
 
 /*!
-  \fn QOrganizerManager::itemsAdded(const QList<QOrganizerItemLocalId>& itemIds)
+  \fn QOrganizerManager::itemsAdded(const QList<QOrganizerItemId>& itemIds)
   This signal is emitted at some point once the items identified by \a itemIds have been added to a datastore managed by this manager.
   This signal will not be emitted if the dataChanged() signal was previously emitted for these changes.
  */
 
 /*!
-  \fn QOrganizerManager::itemsChanged(const QList<QOrganizerItemLocalId>& itemIds)
+  \fn QOrganizerManager::itemsChanged(const QList<QOrganizerItemId>& itemIds)
   This signal is emitted at some point once the items identified by \a itemIds have been modified in a datastore managed by this manager.
   This signal will not be emitted if the dataChanged() signal was previously emitted for these changes.
  */
 
 /*!
-  \fn QOrganizerManager::itemsRemoved(const QList<QOrganizerItemLocalId>& itemIds)
+  \fn QOrganizerManager::itemsRemoved(const QList<QOrganizerItemId>& itemIds)
   This signal is emitted at some point once the items identified by \a itemIds have been removed from a datastore managed by this manager.
   This signal will not be emitted if the dataChanged() signal was previously emitted for these changes.
  */
@@ -278,9 +278,9 @@ void QOrganizerManager::createEngine(const QString& managerName, const QMap<QStr
 {
     d->createEngine(managerName, parameters);
     connect(d->m_engine, SIGNAL(dataChanged()), this, SIGNAL(dataChanged()));
-    connect(d->m_engine, SIGNAL(itemsAdded(QList<QOrganizerItemLocalId>)), this, SIGNAL(itemsAdded(QList<QOrganizerItemLocalId>)));
-    connect(d->m_engine, SIGNAL(itemsChanged(QList<QOrganizerItemLocalId>)), this, SIGNAL(itemsChanged(QList<QOrganizerItemLocalId>)));
-    connect(d->m_engine, SIGNAL(itemsRemoved(QList<QOrganizerItemLocalId>)), this, SIGNAL(itemsRemoved(QList<QOrganizerItemLocalId>)));
+    connect(d->m_engine, SIGNAL(itemsAdded(QList<QOrganizerItemId>)), this, SIGNAL(itemsAdded(QList<QOrganizerItemId>)));
+    connect(d->m_engine, SIGNAL(itemsChanged(QList<QOrganizerItemId>)), this, SIGNAL(itemsChanged(QList<QOrganizerItemId>)));
+    connect(d->m_engine, SIGNAL(itemsRemoved(QList<QOrganizerItemId>)), this, SIGNAL(itemsRemoved(QList<QOrganizerItemId>)));
     connect(d->m_engine, SIGNAL(collectionsAdded(QList<QOrganizerCollectionLocalId>)), this, SIGNAL(collectionsAdded(QList<QOrganizerCollectionLocalId>)));
     connect(d->m_engine, SIGNAL(collectionsChanged(QList<QOrganizerCollectionLocalId>)), this, SIGNAL(collectionsChanged(QList<QOrganizerCollectionLocalId>)));
     connect(d->m_engine, SIGNAL(collectionsRemoved(QList<QOrganizerCollectionLocalId>)), this, SIGNAL(collectionsRemoved(QList<QOrganizerCollectionLocalId>)));
@@ -376,7 +376,7 @@ QList<QOrganizerItem> QOrganizerManager::itemOccurrences(const QOrganizerItem& p
   Returns a list of organizer item ids that match the given \a filter, sorted according to the given list of \a sortOrders.
   Depending on the backend, this filtering operation may involve retrieving all the organizeritems.
  */
-QList<QOrganizerItemLocalId> QOrganizerManager::itemIds(const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders) const
+QList<QOrganizerItemId> QOrganizerManager::itemIds(const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders) const
 {
     d->m_error = QOrganizerManager::NoError;
     return d->m_engine->itemIds(QDateTime(), QDateTime(), filter, sortOrders, &d->m_error);
@@ -390,7 +390,7 @@ QList<QOrganizerItemLocalId> QOrganizerManager::itemIds(const QOrganizerItemFilt
   If both the \a startDate and \a endDate are invalid, this function will return the ids of all items which match the \a filter criteria.
   Depending on the backend, this filtering operation may involve retrieving all the organizeritems.
  */
-QList<QOrganizerItemLocalId> QOrganizerManager::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders) const
+QList<QOrganizerItemId> QOrganizerManager::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders) const
 {
     d->m_error = QOrganizerManager::NoError;
     d->m_errorMap.clear();
@@ -487,7 +487,7 @@ QList<QOrganizerItem> QOrganizerManager::itemsForExport(const QDateTime& startDa
 
   \sa QOrganizerItemFetchHint
  */
-QOrganizerItem QOrganizerManager::item(const QOrganizerItemLocalId& organizeritemId, const QOrganizerItemFetchHint& fetchHint) const
+QOrganizerItem QOrganizerManager::item(const QOrganizerItemId& organizeritemId, const QOrganizerItemFetchHint& fetchHint) const
 {
     d->m_error = QOrganizerManager::NoError;
     d->m_errorMap.clear();
@@ -544,7 +544,7 @@ bool QOrganizerManager::saveItem(QOrganizerItem* organizeritem)
   Returns true if the organizer item was removed successfully, otherwise
   returns false.
  */
-bool QOrganizerManager::removeItem(const QOrganizerItemLocalId& organizeritemId)
+bool QOrganizerManager::removeItem(const QOrganizerItemId& organizeritemId)
 {
     d->m_error = QOrganizerManager::NoError;
     d->m_errorMap.clear();
@@ -603,7 +603,7 @@ bool QOrganizerManager::saveItems(QList<QOrganizerItem>* organizeritems)
 
   \sa QOrganizerManager::removeItem()
  */
-bool QOrganizerManager::removeItems(const QList<QOrganizerItemLocalId>& organizeritemIds)
+bool QOrganizerManager::removeItems(const QList<QOrganizerItemId>& organizeritemIds)
 {
     d->m_errorMap.clear();
     if (organizeritemIds.isEmpty()) {
@@ -838,12 +838,12 @@ QString QOrganizerManager::managerUri() const
     return d->m_engine->managerUri();
 }
 
-/*! Return a list of QOrganizerItemLocalId extracted from the \a items */
-QList<QOrganizerItemLocalId> QOrganizerManager::extractLocalIds(QList<QOrganizerItem> items)
+/*! Return a list of QOrganizerItemId extracted from the \a items */
+QList<QOrganizerItemId> QOrganizerManager::extractLocalIds(QList<QOrganizerItem> items)
 {
-    QList<QOrganizerItemLocalId> ids;
+    QList<QOrganizerItemId> ids;
     foreach(QOrganizerItem item, items)
-        ids.append(item.localId());
+        ids.append(item.id());
     return ids;
 }
 
diff --git a/src/organizer/qorganizermanager.h b/src/organizer/qorganizermanager.h
index d56bc9f790..a019bb7529 100644
--- a/src/organizer/qorganizermanager.h
+++ b/src/organizer/qorganizermanager.h
@@ -115,19 +115,19 @@ public:
     QList<QOrganizerItem> itemOccurrences(const QOrganizerItem& parentItem, const QDateTime& periodStart = QDateTime(), const QDateTime& periodEnd = QDateTime(), int maxCount = -1, const QOrganizerItemFetchHint& fetchHint = QOrganizerItemFetchHint()) const;
 
     /* Items - Accessors and Mutators */
-    QList<QOrganizerItemLocalId> itemIds(const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>()) const;
-    QList<QOrganizerItemLocalId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>()) const;
+    QList<QOrganizerItemId> itemIds(const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>()) const;
+    QList<QOrganizerItemId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>()) const;
 
     QList<QOrganizerItem> items(const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>(), const QOrganizerItemFetchHint& fetchHint = QOrganizerItemFetchHint()) const;
     QList<QOrganizerItem> items(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>(), const QOrganizerItemFetchHint& fetchHint = QOrganizerItemFetchHint()) const;
     QList<QOrganizerItem> itemsForExport(const QDateTime& startDate = QDateTime(), const QDateTime& endDate = QDateTime(), const QOrganizerItemFilter& filter = QOrganizerItemFilter(), const QList<QOrganizerItemSortOrder>& sortOrders = QList<QOrganizerItemSortOrder>(), const QOrganizerItemFetchHint& fetchHint = QOrganizerItemFetchHint()) const;
 
-    QOrganizerItem item(const QOrganizerItemLocalId& itemId, const QOrganizerItemFetchHint& fetchHint = QOrganizerItemFetchHint()) const;  // retrieve an item
+    QOrganizerItem item(const QOrganizerItemId& itemId, const QOrganizerItemFetchHint& fetchHint = QOrganizerItemFetchHint()) const;  // retrieve an item
 
     bool saveItem(QOrganizerItem* item);
     bool saveItems(QList<QOrganizerItem>* items);
-    bool removeItem(const QOrganizerItemLocalId& itemId);
-    bool removeItems(const QList<QOrganizerItemLocalId>& itemIds);
+    bool removeItem(const QOrganizerItemId& itemId);
+    bool removeItems(const QList<QOrganizerItemId>& itemIds);
 
     /* Collections - every item belongs to one or more collections */
     QOrganizerCollection defaultCollection() const;
@@ -159,13 +159,13 @@ public:
     /* return a list of available backends for which a QOrganizerManager can be constructed. */
     static QStringList availableManagers();
 
-    static QList<QOrganizerItemLocalId> extractLocalIds(QList<QOrganizerItem> items);
+    static QList<QOrganizerItemId> extractLocalIds(QList<QOrganizerItem> items);
 
 Q_SIGNALS:
     void dataChanged();
-    void itemsAdded(const QList<QOrganizerItemLocalId>& itemIds);
-    void itemsChanged(const QList<QOrganizerItemLocalId>& itemIds);
-    void itemsRemoved(const QList<QOrganizerItemLocalId>& itemIds);
+    void itemsAdded(const QList<QOrganizerItemId>& itemIds);
+    void itemsChanged(const QList<QOrganizerItemId>& itemIds);
+    void itemsRemoved(const QList<QOrganizerItemId>& itemIds);
     void collectionsAdded(const QList<QOrganizerCollectionLocalId>& collectionIds);
     void collectionsChanged(const QList<QOrganizerCollectionLocalId>& collectionIds);
     void collectionsRemoved(const QList<QOrganizerCollectionLocalId>& collectionIds);
diff --git a/src/organizer/qorganizermanager_p.cpp b/src/organizer/qorganizermanager_p.cpp
index 0179380e0a..88dc178541 100644
--- a/src/organizer/qorganizermanager_p.cpp
+++ b/src/organizer/qorganizermanager_p.cpp
@@ -259,7 +259,7 @@ void QOrganizerManagerData::loadFactories()
 }
 
 /* Caller takes ownership of the id */
-QOrganizerItemEngineLocalId* QOrganizerManagerData::createEngineItemLocalId(const QString& uri)
+QOrganizerItemEngineLocalId* QOrganizerManagerData::createEngineItemId(const QString& uri)
 {
     QString managerName;
     QOrganizerManager::parseUri(uri, &managerName, NULL);
diff --git a/src/organizer/qorganizermanager_p.h b/src/organizer/qorganizermanager_p.h
index 66271f069a..9d6f237698 100644
--- a/src/organizer/qorganizermanager_p.h
+++ b/src/organizer/qorganizermanager_p.h
@@ -83,7 +83,7 @@ public:
 
     void createEngine(const QString& managerName, const QMap<QString, QString>& parameters);
     static QOrganizerManagerEngine* engine(const QOrganizerManager* manager);
-    static QOrganizerItemEngineLocalId* createEngineItemLocalId(const QString& uri);
+    static QOrganizerItemEngineLocalId* createEngineItemId(const QString& uri);
     static QOrganizerCollectionEngineLocalId* createEngineCollectionLocalId(const QString& uri);
 
     QOrganizerManagerEngine* m_engine;
diff --git a/src/organizer/qorganizermanagerengine.cpp b/src/organizer/qorganizermanagerengine.cpp
index 013db1ba10..bd8df0976f 100644
--- a/src/organizer/qorganizermanagerengine.cpp
+++ b/src/organizer/qorganizermanagerengine.cpp
@@ -104,7 +104,7 @@ QTM_BEGIN_NAMESPACE
  */
 
 /*!
-  \fn QOrganizerManagerEngine::itemsAdded(const QList<QOrganizerItemLocalId>& organizeritemIds);
+  \fn QOrganizerManagerEngine::itemsAdded(const QList<QOrganizerItemId>& organizeritemIds);
 
   This signal is emitted some time after a set of organizer items has been added to
   this engine where the \l dataChanged() signal was not emitted for those changes.
@@ -118,7 +118,7 @@ QTM_BEGIN_NAMESPACE
  */
 
 /*!
-  \fn QOrganizerManagerEngine::itemsChanged(const QList<QOrganizerItemLocalId>& organizeritemIds);
+  \fn QOrganizerManagerEngine::itemsChanged(const QList<QOrganizerItemId>& organizeritemIds);
 
   This signal is emitted some time after a set of organizer items has been modified in
   this engine where the \l dataChanged() signal was not emitted for those changes.
@@ -132,7 +132,7 @@ QTM_BEGIN_NAMESPACE
  */
 
 /*!
-  \fn QOrganizerManagerEngine::itemsRemoved(const QList<QOrganizerItemLocalId>& organizeritemIds);
+  \fn QOrganizerManagerEngine::itemsRemoved(const QList<QOrganizerItemId>& organizeritemIds);
 
   This signal is emitted some time after a set of organizer items has been removed from
   this engine where the \l dataChanged() signal was not emitted for those changes.
@@ -238,7 +238,7 @@ QList<QOrganizerItem> QOrganizerManagerEngine::itemOccurrences(const QOrganizerI
   Depending on the backend, this filtering operation may involve retrieving
   all the organizer items.  Any error which occurs will be saved in \a error.
  */
-QList<QOrganizerItemLocalId> QOrganizerManagerEngine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const
+QList<QOrganizerItemId> QOrganizerManagerEngine::itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const
 {
     Q_UNUSED(startDate);
     Q_UNUSED(endDate);
@@ -246,7 +246,7 @@ QList<QOrganizerItemLocalId> QOrganizerManagerEngine::itemIds(const QDateTime& s
     Q_UNUSED(sortOrders);
 
     *error = QOrganizerManager::NotSupportedError;
-    return QList<QOrganizerItemLocalId>();
+    return QList<QOrganizerItemId>();
 }
 
 /*!
@@ -333,7 +333,7 @@ QList<QOrganizerItem> QOrganizerManagerEngine::itemsForExport(const QDateTime& s
 
   \sa QOrganizerItemFetchHint
  */
-QOrganizerItem QOrganizerManagerEngine::item(const QOrganizerItemLocalId& organizeritemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const
+QOrganizerItem QOrganizerManagerEngine::item(const QOrganizerItemId& organizeritemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const
 {
     Q_UNUSED(organizeritemId);
     Q_UNUSED(fetchHint);
@@ -365,7 +365,7 @@ bool QOrganizerManagerEngine::hasFeature(QOrganizerManager::ManagerFeature featu
      with a default QOrganizerItemFilter
    \o An empty QOrganizerItemIntersectionFilter will be replaced with a QOrganizerItemDefaultFilter
    \o An empty QOrganizerItemUnionFilter will be replaced with a QOrganizerItemInvalidFilter
-   \o An empty QOrganizerItemLocalIdFilter will be replaced with a QOrganizerItemInvalidFilter
+   \o An empty QOrganizerItemIdFilter will be replaced with a QOrganizerItemInvalidFilter
    \o An intersection or union filter with a single entry will be replaced by that entry
    \o A QOrganizerItemDetailFilter or QOrganizerItemDetailRangeFilter with no definition name will be replaced with a QOrganizerItemInvalidFilter
    \o A QOrganizerItemDetailRangeFilter with no range specified will be converted to a QOrganizerItemDetailFilter
@@ -434,7 +434,7 @@ QOrganizerItemFilter QOrganizerManagerEngine::canonicalizedFilter(const QOrganiz
 
         case QOrganizerItemFilter::LocalIdFilter:
         {
-            QOrganizerItemLocalIdFilter f(filter);
+            QOrganizerItemIdFilter f(filter);
             if (f.ids().count() == 0)
                 return QOrganizerItemInvalidFilter();
         }
@@ -861,9 +861,9 @@ QMap<QString, QMap<QString, QOrganizerItemDetailDefinition> > QOrganizerManagerE
     // instance origin
     d.setName(QOrganizerItemParent::DefinitionName);
     fields.clear();
-    f.setDataType(qMetaTypeId<QOrganizerItemLocalId>());
+    f.setDataType(qMetaTypeId<QOrganizerItemId>());
     f.setAllowableValues(QVariantList());
-    fields.insert(QOrganizerItemParent::FieldParentLocalId, f);
+    fields.insert(QOrganizerItemParent::FieldParentId, f);
     f.setDataType(QVariant::Date);
     fields.insert(QOrganizerItemParent::FieldOriginalDate, f);
     d.setFields(fields);
@@ -1254,9 +1254,9 @@ QMap<QString, QMap<QString, QOrganizerItemDetailDefinition> > QOrganizerManagerE
     // instance origin
     d.setName(QOrganizerItemParent::DefinitionName);
     fields.clear();
-    f.setDataType(qMetaTypeId<QOrganizerItemLocalId>());
+    f.setDataType(qMetaTypeId<QOrganizerItemId>());
     f.setAllowableValues(QVariantList());
-    fields.insert(QOrganizerItemParent::FieldParentLocalId, f);
+    fields.insert(QOrganizerItemParent::FieldParentId, f);
     f.setDataType(QVariant::Date);
     fields.insert(QOrganizerItemParent::FieldOriginalDate, f);
     d.setFields(fields);
@@ -1768,10 +1768,10 @@ bool QOrganizerManagerEngine::saveItem(QOrganizerItem* organizeritem, QOrganizer
 
   The default implementation will convert this into a call to removeItems.
  */
-bool QOrganizerManagerEngine::removeItem(const QOrganizerItemLocalId& organizeritemId, QOrganizerManager::Error* error)
+bool QOrganizerManagerEngine::removeItem(const QOrganizerItemId& organizeritemId, QOrganizerManager::Error* error)
 {
     // Convert to a list op
-    QList<QOrganizerItemLocalId> list;
+    QList<QOrganizerItemId> list;
     list.append(organizeritemId);
 
     QMap<int, QOrganizerManager::Error> errors;
@@ -1851,7 +1851,7 @@ bool QOrganizerManagerEngine::saveItems(QList<QOrganizerItem>* organizeritems, Q
 
   \sa QOrganizerManager::removeItem()
  */
-bool QOrganizerManagerEngine::removeItems(const QList<QOrganizerItemLocalId>& organizeritemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error)
+bool QOrganizerManagerEngine::removeItems(const QList<QOrganizerItemId>& organizeritemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error)
 {
     Q_UNUSED(organizeritemIds);
     Q_UNUSED(errorMap);
@@ -2095,8 +2095,8 @@ bool QOrganizerManagerEngine::testFilter(const QOrganizerItemFilter &filter, con
 
         case QOrganizerItemFilter::LocalIdFilter:
             {
-                const QOrganizerItemLocalIdFilter idf(filter);
-                if (idf.ids().contains(organizeritem.id().localId()))
+                const QOrganizerItemIdFilter idf(filter);
+                if (idf.ids().contains(organizeritem.id()))
                     return true;
             }
             // Fall through to end
@@ -2370,8 +2370,8 @@ bool QOrganizerManagerEngine::isItemBetweenDates(const QOrganizerItem& item, con
 
     // if period end date is not given, check that item is starting or ending after the period start
     if (endPeriod.isNull())   // startPeriod must be non-null because of initial test
-        return !itemDateEnd.isNull() && itemDateEnd >= startPeriod ||
-               !itemDateStart.isNull() && itemDateStart >= startPeriod;
+        return (!itemDateEnd.isNull() && itemDateEnd >= startPeriod) ||
+               (!itemDateStart.isNull() && itemDateStart >= startPeriod);
 
     // Both startPeriod and endPeriod are not null
     // check if item start date is between the period start and end date
@@ -2464,7 +2464,7 @@ void QOrganizerManagerEngine::addSorted(QList<QOrganizerItem>* sorted, const QOr
   Returns the engine local id from the given \a localId.
   The caller does not take ownership of the pointer, and should not delete returned id or undefined behavior may occur.
  */
-QOrganizerItemEngineLocalId* QOrganizerManagerEngine::engineLocalItemId(const QOrganizerItemLocalId& localId)
+QOrganizerItemEngineLocalId* QOrganizerManagerEngine::engineLocalItemId(const QOrganizerItemId& localId)
 {
     return localId.d;
 }
@@ -2605,18 +2605,18 @@ void QOrganizerManagerEngine::updateItemOccurrenceFetchRequest(QOrganizerItemOcc
 }
 
 /*!
-  Updates the given QOrganizerItemLocalIdFetchRequest \a req with the latest results \a result, and operation error \a error.
+  Updates the given QOrganizerItemIdFetchRequest \a req with the latest results \a result, and operation error \a error.
   In addition, the state of the request will be changed to \a newState.
 
   It then causes the request to emit its resultsAvailable() signal to notify clients of the request progress.
 
   If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
  */
-void QOrganizerManagerEngine::updateItemLocalIdFetchRequest(QOrganizerItemLocalIdFetchRequest* req, const QList<QOrganizerItemLocalId>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState)
+void QOrganizerManagerEngine::updateItemIdFetchRequest(QOrganizerItemIdFetchRequest* req, const QList<QOrganizerItemId>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState)
 {
     if (req) {
-        QWeakPointer<QOrganizerItemLocalIdFetchRequest> ireq(req); // Take this in case the first emit deletes us
-        QOrganizerItemLocalIdFetchRequestPrivate* rd = static_cast<QOrganizerItemLocalIdFetchRequestPrivate*>(ireq.data()->d_ptr);
+        QWeakPointer<QOrganizerItemIdFetchRequest> ireq(req); // Take this in case the first emit deletes us
+        QOrganizerItemIdFetchRequestPrivate* rd = static_cast<QOrganizerItemIdFetchRequestPrivate*>(ireq.data()->d_ptr);
         QMutexLocker ml(&rd->m_mutex);
         bool emitState = rd->m_state != newState;
         rd->m_ids = result;
diff --git a/src/organizer/qorganizermanagerengine.h b/src/organizer/qorganizermanagerengine.h
index 45688c2774..cd8170b785 100644
--- a/src/organizer/qorganizermanagerengine.h
+++ b/src/organizer/qorganizermanagerengine.h
@@ -68,7 +68,7 @@ class QOrganizerItemEngineLocalId;
 
 /* Forward decls, since these don't actually exist yet */
 class QOrganizerItemOccurrenceFetchRequest;
-class QOrganizerItemLocalIdFetchRequest;
+class QOrganizerItemIdFetchRequest;
 class QOrganizerItemFetchRequest;
 class QOrganizerItemRemoveRequest;
 class QOrganizerItemSaveRequest;
@@ -94,16 +94,16 @@ public:
 
     /* Filtering */
     virtual QList<QOrganizerItem> itemOccurrences(const QOrganizerItem& parentItem, const QDateTime& periodStart, const QDateTime& periodEnd, int maxCount, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
-    virtual QList<QOrganizerItemLocalId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const;
+    virtual QList<QOrganizerItemId> itemIds(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerManager::Error* error) const;
     virtual QList<QOrganizerItem> items(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
     virtual QList<QOrganizerItem> itemsForExport(const QDateTime& startDate, const QDateTime& endDate, const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
-    virtual QOrganizerItem item(const QOrganizerItemLocalId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
+    virtual QOrganizerItem item(const QOrganizerItemId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerManager::Error* error) const;
 
     virtual bool saveItem(QOrganizerItem* item, QOrganizerManager::Error* error);
-    virtual bool removeItem(const QOrganizerItemLocalId& itemId, QOrganizerManager::Error* error);
+    virtual bool removeItem(const QOrganizerItemId& itemId, QOrganizerManager::Error* error);
 
     virtual bool saveItems(QList<QOrganizerItem>* items, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
-    virtual bool removeItems(const QList<QOrganizerItemLocalId>& itemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
+    virtual bool removeItems(const QList<QOrganizerItemId>& itemIds, QMap<int, QOrganizerManager::Error>* errorMap, QOrganizerManager::Error* error);
 
     /* Collections - every item belongs to exactly one collection */
     virtual QOrganizerCollection defaultCollection(QOrganizerManager::Error* error) const;
@@ -143,9 +143,9 @@ public:
 
 Q_SIGNALS:
     void dataChanged();
-    void itemsAdded(const QList<QOrganizerItemLocalId>& itemIds);
-    void itemsChanged(const QList<QOrganizerItemLocalId>& itemIds);
-    void itemsRemoved(const QList<QOrganizerItemLocalId>& itemIds);
+    void itemsAdded(const QList<QOrganizerItemId>& itemIds);
+    void itemsChanged(const QList<QOrganizerItemId>& itemIds);
+    void itemsRemoved(const QList<QOrganizerItemId>& itemIds);
     void collectionsAdded(const QList<QOrganizerCollectionLocalId>& collectionIds);
     void collectionsChanged(const QList<QOrganizerCollectionLocalId>& collectionIds);
     void collectionsRemoved(const QList<QOrganizerCollectionLocalId>& collectionIds);
@@ -155,7 +155,7 @@ public:
     static void updateRequestState(QOrganizerAbstractRequest* req, QOrganizerAbstractRequest::State state);
 
     static void updateItemOccurrenceFetchRequest(QOrganizerItemOccurrenceFetchRequest* req, const QList<QOrganizerItem>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState);
-    static void updateItemLocalIdFetchRequest(QOrganizerItemLocalIdFetchRequest* req, const QList<QOrganizerItemLocalId>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState);
+    static void updateItemIdFetchRequest(QOrganizerItemIdFetchRequest* req, const QList<QOrganizerItemId>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState);
     static void updateItemFetchRequest(QOrganizerItemFetchRequest* req, const QList<QOrganizerItem>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState);
     static void updateItemFetchForExportRequest(QOrganizerItemFetchForExportRequest* req, const QList<QOrganizerItem>& result, QOrganizerManager::Error error, QOrganizerAbstractRequest::State newState);
     static void updateItemRemoveRequest(QOrganizerItemRemoveRequest* req, QOrganizerManager::Error error, const QMap<int, QOrganizerManager::Error>& errorMap, QOrganizerAbstractRequest::State newState);
@@ -169,7 +169,7 @@ public:
 
     // Other protected area update functions
     static void setDetailAccessConstraints(QOrganizerItemDetail* detail, QOrganizerItemDetail::AccessConstraints constraints);
-    static QOrganizerItemEngineLocalId* engineLocalItemId(const QOrganizerItemLocalId& localId);
+    static QOrganizerItemEngineLocalId* engineLocalItemId(const QOrganizerItemId& localId);
     static QOrganizerCollectionEngineLocalId* engineLocalCollectionId(const QOrganizerCollectionLocalId& localId);
 
     /* Helper functions */
diff --git a/src/organizer/requests/qorganizeritemlocalidfetchrequest.cpp b/src/organizer/requests/qorganizeritemlocalidfetchrequest.cpp
index 11a89861d3..142fbb23fc 100644
--- a/src/organizer/requests/qorganizeritemlocalidfetchrequest.cpp
+++ b/src/organizer/requests/qorganizeritemlocalidfetchrequest.cpp
@@ -45,13 +45,13 @@
 QTM_BEGIN_NAMESPACE
 
 /*!
-  \class QOrganizerItemLocalIdFetchRequest
-  \brief The QOrganizerItemLocalIdFetchRequest class allows a client to asynchronously
+  \class QOrganizerItemIdFetchRequest
+  \brief The QOrganizerItemIdFetchRequest class allows a client to asynchronously
     request a list of organizer item ids from a organizer item store manager.
   \inmodule QtOrganizer
 
 
-  For a QOrganizerItemLocalIdFetchRequest, the resultsAvailable() signal will be emitted when the resultant
+  For a QOrganizerItemIdFetchRequest, the resultsAvailable() signal will be emitted when the resultant
   manager-local organizer item ids (which may be retrieved by calling ids()), are updated, as well as if
   the overall operation error (which may be retrieved by calling error()) is updated.
 
@@ -59,23 +59,23 @@ QTM_BEGIN_NAMESPACE
  */
 
 /*! Constructs a new organizer item id fetch request whose parent is the specified \a parent */
-QOrganizerItemLocalIdFetchRequest::QOrganizerItemLocalIdFetchRequest(QObject* parent)
-    : QOrganizerAbstractRequest(new QOrganizerItemLocalIdFetchRequestPrivate, parent)
+QOrganizerItemIdFetchRequest::QOrganizerItemIdFetchRequest(QObject* parent)
+    : QOrganizerAbstractRequest(new QOrganizerItemIdFetchRequestPrivate, parent)
 {
 }
 
 /*! Sets the filter which will be used to select the organizer items whose ids will be returned to \a filter */
-void QOrganizerItemLocalIdFetchRequest::setFilter(const QOrganizerItemFilter& filter)
+void QOrganizerItemIdFetchRequest::setFilter(const QOrganizerItemFilter& filter)
 {
-    Q_D(QOrganizerItemLocalIdFetchRequest);
+    Q_D(QOrganizerItemIdFetchRequest);
     d->m_filter = filter;
 }
 
 /*! Sets the future sort ordering of the result of the request to \a sorting.  This function only has
     effect on the result if called prior to calling \c start() */
-void QOrganizerItemLocalIdFetchRequest::setSorting(const QList<QOrganizerItemSortOrder>& sorting)
+void QOrganizerItemIdFetchRequest::setSorting(const QList<QOrganizerItemSortOrder>& sorting)
 {
-    Q_D(QOrganizerItemLocalIdFetchRequest);
+    Q_D(QOrganizerItemIdFetchRequest);
     d->m_sorting = sorting;
 }
 
@@ -85,9 +85,9 @@ void QOrganizerItemLocalIdFetchRequest::setSorting(const QList<QOrganizerItemSor
    up to the end date).
    Note that an item matches if either it or any of its occurrences occur within the defined range.
  */
-void QOrganizerItemLocalIdFetchRequest::setStartDate(const QDateTime &date)
+void QOrganizerItemIdFetchRequest::setStartDate(const QDateTime &date)
 {
-    Q_D(QOrganizerItemLocalIdFetchRequest);
+    Q_D(QOrganizerItemIdFetchRequest);
     d->m_startDate = date;
 }
 
@@ -97,23 +97,23 @@ void QOrganizerItemLocalIdFetchRequest::setStartDate(const QDateTime &date)
    after the start date).
    Note that an item matches if either it or any of its occurrences occur within the defined range.
  */
-void QOrganizerItemLocalIdFetchRequest::setEndDate(const QDateTime &date)
+void QOrganizerItemIdFetchRequest::setEndDate(const QDateTime &date)
 {
-    Q_D(QOrganizerItemLocalIdFetchRequest);
+    Q_D(QOrganizerItemIdFetchRequest);
     d->m_endDate = date;
 }
 
 /*! Returns the filter which will be used to select the organizer items whose ids will be returned */
-QOrganizerItemFilter QOrganizerItemLocalIdFetchRequest::filter() const
+QOrganizerItemFilter QOrganizerItemIdFetchRequest::filter() const
 {
-    Q_D(const QOrganizerItemLocalIdFetchRequest);
+    Q_D(const QOrganizerItemIdFetchRequest);
     return d->m_filter;
 }
 
 /*! Returns the sort ordering which will be used to sort the result */
-QList<QOrganizerItemSortOrder> QOrganizerItemLocalIdFetchRequest::sorting() const
+QList<QOrganizerItemSortOrder> QOrganizerItemIdFetchRequest::sorting() const
 {
-    Q_D(const QOrganizerItemLocalIdFetchRequest);
+    Q_D(const QOrganizerItemIdFetchRequest);
     return d->m_sorting;
 }
 
@@ -123,9 +123,9 @@ QList<QOrganizerItemSortOrder> QOrganizerItemLocalIdFetchRequest::sorting() cons
    up until the end date).
    Note that an item matches if either it or any of its occurrences occur within the defined range.
  */
-QDateTime QOrganizerItemLocalIdFetchRequest::startDate() const
+QDateTime QOrganizerItemIdFetchRequest::startDate() const
 {
-    Q_D(const QOrganizerItemLocalIdFetchRequest);
+    Q_D(const QOrganizerItemIdFetchRequest);
     return d->m_startDate;
 }
 
@@ -135,16 +135,16 @@ QDateTime QOrganizerItemLocalIdFetchRequest::startDate() const
    after the start date).
    Note that an item matches if either it or any of its occurrences occur within the defined range.
  */
-QDateTime QOrganizerItemLocalIdFetchRequest::endDate() const
+QDateTime QOrganizerItemIdFetchRequest::endDate() const
 {
-    Q_D(const QOrganizerItemLocalIdFetchRequest);
+    Q_D(const QOrganizerItemIdFetchRequest);
     return d->m_endDate;
 }
 
 /*! Returns the list of ids of organizer items which matched the request */
-QList<QOrganizerItemLocalId> QOrganizerItemLocalIdFetchRequest::itemIds() const
+QList<QOrganizerItemId> QOrganizerItemIdFetchRequest::itemIds() const
 {
-    Q_D(const QOrganizerItemLocalIdFetchRequest);
+    Q_D(const QOrganizerItemIdFetchRequest);
     return d->m_ids;
 }
 
diff --git a/src/organizer/requests/qorganizeritemlocalidfetchrequest.h b/src/organizer/requests/qorganizeritemlocalidfetchrequest.h
index 52d30f976e..bcd16fe31f 100644
--- a/src/organizer/requests/qorganizeritemlocalidfetchrequest.h
+++ b/src/organizer/requests/qorganizeritemlocalidfetchrequest.h
@@ -52,13 +52,13 @@
 
 QTM_BEGIN_NAMESPACE
 
-class QOrganizerItemLocalIdFetchRequestPrivate;
-class Q_ORGANIZER_EXPORT QOrganizerItemLocalIdFetchRequest : public QOrganizerAbstractRequest
+class QOrganizerItemIdFetchRequestPrivate;
+class Q_ORGANIZER_EXPORT QOrganizerItemIdFetchRequest : public QOrganizerAbstractRequest
 {
     Q_OBJECT
 
 public:
-    QOrganizerItemLocalIdFetchRequest(QObject* parent = 0);
+    QOrganizerItemIdFetchRequest(QObject* parent = 0);
 
     /* Selection, restriction and sorting */
     void setFilter(const QOrganizerItemFilter& filter);
@@ -71,12 +71,12 @@ public:
     QDateTime endDate() const;
 
     /* Results */
-    QList<QOrganizerItemLocalId> itemIds() const;
+    QList<QOrganizerItemId> itemIds() const;
 
 private:
-    Q_DISABLE_COPY(QOrganizerItemLocalIdFetchRequest)
+    Q_DISABLE_COPY(QOrganizerItemIdFetchRequest)
     friend class QOrganizerManagerEngine;
-    Q_DECLARE_PRIVATE_D(d_ptr, QOrganizerItemLocalIdFetchRequest)
+    Q_DECLARE_PRIVATE_D(d_ptr, QOrganizerItemIdFetchRequest)
 };
 
 QTM_END_NAMESPACE
diff --git a/src/organizer/requests/qorganizeritemremoverequest.cpp b/src/organizer/requests/qorganizeritemremoverequest.cpp
index 703cea2d82..57e9efad11 100644
--- a/src/organizer/requests/qorganizeritemremoverequest.cpp
+++ b/src/organizer/requests/qorganizeritemremoverequest.cpp
@@ -67,10 +67,10 @@ QOrganizerItemRemoveRequest::QOrganizerItemRemoveRequest(QObject* parent)
   Sets the id of the organizer item which will be removed to \a organizeritemId.
   Equivalent to calling:
   \code
-      setOrganizerItemIds(QList<QOrganizerItemLocalId>() << organizeritemIds);
+      setOrganizerItemIds(QList<QOrganizerItemId>() << organizeritemIds);
   \endcode
  */
-void QOrganizerItemRemoveRequest::setItemId(const QOrganizerItemLocalId& organizeritemId)
+void QOrganizerItemRemoveRequest::setItemId(const QOrganizerItemId& organizeritemId)
 {
     Q_D(QOrganizerItemRemoveRequest);
     d->m_organizeritemIds.clear();
@@ -78,14 +78,14 @@ void QOrganizerItemRemoveRequest::setItemId(const QOrganizerItemLocalId& organiz
 }
 
 /*! Sets the list of ids of organizer items which will be removed to \a organizeritemIds */
-void QOrganizerItemRemoveRequest::setItemIds(const QList<QOrganizerItemLocalId>& organizeritemIds)
+void QOrganizerItemRemoveRequest::setItemIds(const QList<QOrganizerItemId>& organizeritemIds)
 {
     Q_D(QOrganizerItemRemoveRequest);
     d->m_organizeritemIds = organizeritemIds;
 }
 
 /*! Returns the list of ids of organizer items which will be removed */
-QList<QOrganizerItemLocalId> QOrganizerItemRemoveRequest::itemIds() const
+QList<QOrganizerItemId> QOrganizerItemRemoveRequest::itemIds() const
 {
     Q_D(const QOrganizerItemRemoveRequest);
     return d->m_organizeritemIds;
diff --git a/src/organizer/requests/qorganizeritemremoverequest.h b/src/organizer/requests/qorganizeritemremoverequest.h
index 769bb5f4e3..48f7682e49 100644
--- a/src/organizer/requests/qorganizeritemremoverequest.h
+++ b/src/organizer/requests/qorganizeritemremoverequest.h
@@ -59,9 +59,9 @@ public:
     QOrganizerItemRemoveRequest(QObject* parent = 0);
 
     /* Selection */
-    void setItemId(const QOrganizerItemLocalId& organizeritemId);
-    void setItemIds(const QList<QOrganizerItemLocalId>& organizeritemIds);
-    QList<QOrganizerItemLocalId> itemIds() const;
+    void setItemId(const QOrganizerItemId& organizeritemId);
+    void setItemIds(const QList<QOrganizerItemId>& organizeritemIds);
+    QList<QOrganizerItemId> itemIds() const;
 
     /* Results */
     QMap<int, QOrganizerManager::Error> errorMap() const;
diff --git a/src/organizer/requests/qorganizeritemrequests_p.h b/src/organizer/requests/qorganizeritemrequests_p.h
index cecf00a319..d5fcd3392c 100644
--- a/src/organizer/requests/qorganizeritemrequests_p.h
+++ b/src/organizer/requests/qorganizeritemrequests_p.h
@@ -184,19 +184,19 @@ public:
         return QOrganizerAbstractRequest::ItemRemoveRequest;
     }
 
-    QList<QOrganizerItemLocalId> m_organizeritemIds;
+    QList<QOrganizerItemId> m_organizeritemIds;
     QMap<int, QOrganizerManager::Error> m_errors;
 };
 
-class QOrganizerItemLocalIdFetchRequestPrivate : public QOrganizerAbstractRequestPrivate
+class QOrganizerItemIdFetchRequestPrivate : public QOrganizerAbstractRequestPrivate
 {
 public:
-    QOrganizerItemLocalIdFetchRequestPrivate()
+    QOrganizerItemIdFetchRequestPrivate()
         : QOrganizerAbstractRequestPrivate()
     {
     }
 
-    ~QOrganizerItemLocalIdFetchRequestPrivate()
+    ~QOrganizerItemIdFetchRequestPrivate()
     {
     }
 
@@ -208,7 +208,7 @@ public:
     QOrganizerItemFilter m_filter;
     QList<QOrganizerItemSortOrder> m_sorting;
 
-    QList<QOrganizerItemLocalId> m_ids;
+    QList<QOrganizerItemId> m_ids;
 
     QDateTime m_startDate;
     QDateTime m_endDate;
diff --git a/tests/auto/qorganizeritem/tst_qorganizeritem.cpp b/tests/auto/qorganizeritem/tst_qorganizeritem.cpp
index 5787bf3b10..5061e84406 100644
--- a/tests/auto/qorganizeritem/tst_qorganizeritem.cpp
+++ b/tests/auto/qorganizeritem/tst_qorganizeritem.cpp
@@ -483,11 +483,14 @@ public:
     uint engineLocalIdType() const {
         return 0;
     }
+    QString managerUri() const {
+        return QString::fromLatin1("basicId");
+    }
     QOrganizerItemEngineLocalId* clone() const {
         BasicItemLocalId* cloned = new BasicItemLocalId(m_id);
         return cloned;
     }
-    QDebug debugStreamOut(QDebug dbg) {
+    QDebug& debugStreamOut(QDebug& dbg) {
         return dbg << m_id;
     }
     QDataStream& dataStreamOut(QDataStream& out) {
@@ -507,14 +510,15 @@ private:
     uint m_id;
 };
 
-QOrganizerItemLocalId makeId(uint id)
+QOrganizerItemId makeId(uint id)
 {
-    return QOrganizerItemLocalId(new BasicItemLocalId(id));
+    return QOrganizerItemId(new BasicItemLocalId(id));
 }
 
 void tst_QOrganizerItem::idLessThan()
 {
-    QOrganizerItemId id1;
+    // TODO: review test
+/*    QOrganizerItemId id1;
     id1.setManagerUri("a");
     id1.setLocalId(makeId(1));
     QOrganizerItemId id2;
@@ -537,12 +541,13 @@ void tst_QOrganizerItem::idLessThan()
     QVERIFY(id3 < id4);
     QVERIFY(!(id4 < id3));
     QVERIFY(id5 < id1);
-    QVERIFY(!(id1 < id5));
+    QVERIFY(!(id1 < id5));*/
 }
 
 void tst_QOrganizerItem::idHash()
 {
-    QOrganizerItemId id1;
+    // TODO: review test
+/*    QOrganizerItemId id1;
     id1.setManagerUri("a");
     id1.setLocalId(makeId(1));
     QOrganizerItemId id2;
@@ -557,12 +562,13 @@ void tst_QOrganizerItem::idHash()
     set.insert(id1);
     set.insert(id2);
     set.insert(id3);
-    QCOMPARE(set.size(), 2);
+    QCOMPARE(set.size(), 2);*/
 }
 
 void tst_QOrganizerItem::hash()
 {
-    QOrganizerItemId id;
+    // TODO: review test
+/*    QOrganizerItemId id;
     id.setManagerUri("a");
     id.setLocalId(makeId(1));
     QOrganizerItem oi1;
@@ -586,7 +592,7 @@ void tst_QOrganizerItem::hash()
     QVERIFY(qHash(oi1) == qHash(oi2));
     QVERIFY(qHash(oi1) != qHash(oi3));
     QVERIFY(qHash(oi1) != qHash(oi4));
-    QVERIFY(qHash(oi1) == qHash(oi5));
+    QVERIFY(qHash(oi1) == qHash(oi5));*/
 }
 
 void tst_QOrganizerItem::datastream()
@@ -615,8 +621,9 @@ void tst_QOrganizerItem::datastream()
         QVERIFY(itemOut.id() == itemIn.id());
     }
 
+    // TODO : review tests
     // second, stream an item with an id with the mgr uri set, local id null
-    {
+/*    {
         QDataStream stream1(&buffer, QIODevice::WriteOnly);
         QOrganizerItemId modifiedId = originalId;
         modifiedId.setLocalId(QOrganizerItemLocalId());
@@ -644,7 +651,7 @@ void tst_QOrganizerItem::datastream()
         //QCOMPARE(itemOut, itemIn); // can't do QCOMPARE because detail keys get changed.
         QVERIFY(itemOut.details() == itemIn.details());
         QVERIFY(itemOut.id() != itemIn.id()); // in this case, with null mgr uri, the id doesn't get serialized.
-    }
+    }*/
 
     // fourth, stream an item with null ids
     {
@@ -692,8 +699,9 @@ void tst_QOrganizerItem::datastream()
         QCOMPARE(inputId, outputId);
     }
 
+    // TODO : review tests
     // second, stream a partial id (mgr uri null, local id set)
-    {
+/*    {
         inputId.setManagerUri(QString());
         inputId.setLocalId(originalId.localId());
         buffer.clear();
@@ -719,7 +727,7 @@ void tst_QOrganizerItem::datastream()
         QDataStream stream2(buffer);
         stream2 >> outputId;
         QCOMPARE(inputId, outputId);
-    }
+    }*/
 
     // fourth, stream a null id
     {
@@ -733,8 +741,9 @@ void tst_QOrganizerItem::datastream()
         QCOMPARE(inputId, outputId);
     }
 
+    // TODO : review tests
     // fifth, stream an id after changing it's manager uri string.
-    {
+/*    {
         inputId.setManagerUri(originalId.managerUri());
         inputId.setLocalId(originalId.localId());
         inputId.setManagerUri("test manager uri"); // should clear the local id.
@@ -762,7 +771,7 @@ void tst_QOrganizerItem::datastream()
         QDataStream stream2(buffer);
         stream2 >> outputId;
         QVERIFY(outputId.isNull());
-    }
+    }*/
 }
 
 void tst_QOrganizerItem::traits()
@@ -789,8 +798,8 @@ void tst_QOrganizerItem::idTraits()
 
 void tst_QOrganizerItem::localIdTraits()
 {
-    QVERIFY(sizeof(QOrganizerItemLocalId) == sizeof(void *));
-    QTypeInfo<QTM_PREPEND_NAMESPACE(QOrganizerItemLocalId)> ti;
+    QVERIFY(sizeof(QOrganizerItemId) == sizeof(void *));
+    QTypeInfo<QTM_PREPEND_NAMESPACE(QOrganizerItemId)> ti;
     QVERIFY(ti.isComplex); // unlike QContactLocalId (int typedef), we have a ctor
     QVERIFY(!ti.isStatic);
     QVERIFY(!ti.isLarge);
diff --git a/tests/auto/qorganizeritemasync/unittest/tst_qorganizeritemasync.cpp b/tests/auto/qorganizeritemasync/unittest/tst_qorganizeritemasync.cpp
index 78733f0aec..5ded45048d 100644
--- a/tests/auto/qorganizeritemasync/unittest/tst_qorganizeritemasync.cpp
+++ b/tests/auto/qorganizeritemasync/unittest/tst_qorganizeritemasync.cpp
@@ -280,7 +280,7 @@ bool tst_QOrganizerItemAsync::compareItems(QOrganizerItem ca, QOrganizerItem cb)
 {
     // NOTE: This compare is item detail order insensitive.
     
-    if (ca.localId() != cb.localId())
+    if (ca.id() != cb.id())
         return false;
     
     QList<QOrganizerItemDetail> aDetails = ca.details();
@@ -435,7 +435,7 @@ void tst_QOrganizerItemAsync::itemFetch()
     QVERIFY(spy.count() >= 1); // active + finished progress signals
     spy.clear();
 
-    QList<QOrganizerItemLocalId> itemIds = oim->itemIds();
+    QList<QOrganizerItemId> itemIds = oim->itemIds();
     QList<QOrganizerItem> items = ifr.items();
     QCOMPARE(itemIds.size(), items.size());
     for (int i = 0; i < itemIds.size(); i++) {
@@ -655,7 +655,7 @@ void tst_QOrganizerItemAsync::itemFetchById()
     QVERIFY(!ifr.waitForFinished());
 
     // get all item ids
-    QList<QOrganizerItemLocalId> itemIds(oim->itemIds());
+    QList<QOrganizerItemId> itemIds(oim->itemIds());
 
     // "all items" retrieval
     ifr.setManager(oim.data());
@@ -692,7 +692,7 @@ void tst_QOrganizerItemAsync::itemIdFetch()
 {
     QFETCH(QString, uri);
     QScopedPointer<QOrganizerManager> oim(prepareModel(uri));
-    QOrganizerItemLocalIdFetchRequest ifr;
+    QOrganizerItemIdFetchRequest ifr;
     QVERIFY(ifr.type() == QOrganizerAbstractRequest::ItemLocalIdFetchRequest);
 
     // initial state - not started, no manager.
@@ -710,7 +710,7 @@ void tst_QOrganizerItemAsync::itemIdFetch()
     QVERIFY(!ifr.isFinished());
     QVERIFY(!ifr.cancel());
     QVERIFY(!ifr.waitForFinished());
-    qRegisterMetaType<QOrganizerItemLocalIdFetchRequest*>("QOrganizerItemLocalIdFetchRequest*");
+    qRegisterMetaType<QOrganizerItemIdFetchRequest*>("QOrganizerItemIdFetchRequest*");
 
     QThreadSignalSpy spy(&ifr, SIGNAL(stateChanged(QOrganizerAbstractRequest::State)));
     ifr.setFilter(fil);
@@ -726,8 +726,8 @@ void tst_QOrganizerItemAsync::itemIdFetch()
     QVERIFY(spy.count() >= 1); // active + finished progress signals
     spy.clear();
 
-    QList<QOrganizerItemLocalId> itemIds = oim->itemIds();
-    QList<QOrganizerItemLocalId> result = ifr.itemIds();
+    QList<QOrganizerItemId> itemIds = oim->itemIds();
+    QList<QOrganizerItemId> result = ifr.itemIds();
     QCOMPARE(itemIds, result);
 
     // asynchronous detail filtering
@@ -844,7 +844,7 @@ void tst_QOrganizerItemAsync::itemRemove()
     QFETCH(QString, uri);
     QScopedPointer<QOrganizerManager> oim(prepareModel(uri));
 
-    qRegisterMetaType<QList<QOrganizerItemLocalId> >("QList<QOrganizerItemLocalId>");
+    qRegisterMetaType<QList<QOrganizerItemId> >("QList<QOrganizerItemId>");
 
     QOrganizerItemRemoveRequest irr;
     QVERIFY(irr.type() == QOrganizerAbstractRequest::ItemRemoveRequest);
@@ -871,13 +871,13 @@ void tst_QOrganizerItemAsync::itemRemove()
     testTodo1.saveDetail(&comment);
     QVERIFY(oim->saveItem(&testTodo1));
 
-    QList<QOrganizerItemLocalId> allIds(oim->itemIds());
+    QList<QOrganizerItemId> allIds(oim->itemIds());
     QVERIFY(!allIds.isEmpty());
-    QOrganizerItemLocalId removableId(allIds.first());
+    QOrganizerItemId removableId(allIds.first());
 
     // specific item set
     irr.setItemId(removableId);
-    QVERIFY(irr.itemIds() == QList<QOrganizerItemLocalId>() << removableId);
+    QVERIFY(irr.itemIds() == QList<QOrganizerItemId>() << removableId);
 
     // specific item removal via detail filter
     int originalCount = oim->itemIds().size();
@@ -1046,7 +1046,7 @@ void tst_QOrganizerItemAsync::itemSave()
     QList<QOrganizerItem> expected = isr.items();
     QCOMPARE(expected.size(), 1);
     QList<QOrganizerItem> result;
-    result << oim->item(expected.first().id().localId());
+    result << oim->item(expected.first().id());
     //some backends add extra fields, so this doesn't work:
     //QCOMPARE(result, expected);
     // XXX: really, we should use isSuperset() from tst_QOrganizerManager, but this will do for now:
@@ -1075,7 +1075,7 @@ void tst_QOrganizerItemAsync::itemSave()
 
     expected = isr.items();
     result.clear();
-    result << oim->item(expected.first().id().localId());
+    result << oim->item(expected.first().id());
 
     QVERIFY(compareItemLists(result, expected));
 
@@ -1102,7 +1102,7 @@ void tst_QOrganizerItemAsync::itemSave()
             // after the request has already finished.. so loop and try again.
             isr.waitForFinished();
             saveList = isr.items();
-            if (oim->itemIds().size() > (originalCount + 1) && !oim->removeItem(saveList.at(0).localId())) {
+            if (oim->itemIds().size() > (originalCount + 1) && !oim->removeItem(saveList.at(0).id())) {
                 QSKIP("Unable to remove saved item to test cancellation of item save request", SkipSingle);
             }
             saveList.clear();
@@ -1126,7 +1126,7 @@ void tst_QOrganizerItemAsync::itemSave()
 
         // verify that the changes were not saved
         expected.clear();
-        QList<QOrganizerItemLocalId> allItems = oim->itemIds();
+        QList<QOrganizerItemId> allItems = oim->itemIds();
         for (int i = 0; i < allItems.size(); i++) {
             expected.append(oim->item(allItems.at(i)));
         }
@@ -1145,7 +1145,7 @@ void tst_QOrganizerItemAsync::itemSave()
             // after the request has already finished.. so loop and try again.
             isr.waitForFinished();
             saveList = isr.items();
-            if (oim->itemIds().size() > (originalCount + 1) && !oim->removeItem(saveList.at(0).localId())) {
+            if (oim->itemIds().size() > (originalCount + 1) && !oim->removeItem(saveList.at(0).id())) {
                 QSKIP("Unable to remove saved item to test cancellation of item save request", SkipSingle);
             }
             saveList.clear();
@@ -1167,7 +1167,7 @@ void tst_QOrganizerItemAsync::itemSave()
 
         // verify that the changes were not saved
         expected.clear();
-        QList<QOrganizerItemLocalId> allItems = oim->itemIds();
+        QList<QOrganizerItemId> allItems = oim->itemIds();
         for (int i = 0; i < allItems.size(); i++) {
             expected.append(oim->item(allItems.at(i)));
         }
@@ -1188,9 +1188,9 @@ void tst_QOrganizerItemAsync::itemPartialSave()
     QList<QOrganizerItem> originalItems(items);
     QCOMPARE(items.count(), 3);
 
-    QOrganizerItemLocalId aId = items[0].localId();
-    QOrganizerItemLocalId bId = items[1].localId();
-    QOrganizerItemLocalId cId = items[2].localId();
+    QOrganizerItemId aId = items[0].id();
+    QOrganizerItemId bId = items[1].id();
+    QOrganizerItemId cId = items[2].id();
 
     // Test 1: saving a item with a changed detail masked out does nothing
     QOrganizerItemPriority priority(items[0].detail<QOrganizerItemPriority>());
@@ -1260,13 +1260,13 @@ void tst_QOrganizerItemAsync::itemPartialSave()
     QVERIFY(isr.errorMap().isEmpty());
     items = isr.items();
     QCOMPARE(items.size()-1, 3);  // Just check that we are dealing with the item at index 3
-    QOrganizerItemLocalId dId = items[3].localId();
+    QOrganizerItemId dId = items[3].id();
     items[3] = oim->item(dId);
     QVERIFY(items[3].details<QOrganizerItemEmailAddress>().count() == 0); // not saved
     QVERIFY(items[3].details<QOrganizerItemPriority>().count() == 0); // not saved
 
     // 5 - New item, some details in the mask
-    QVERIFY(newContact.localId() == 0);
+    QVERIFY(newContact.id() == 0);
     QVERIFY(newContact.details<QOrganizerItemEmailAddress>().count() == 1);
     QVERIFY(newContact.details<QOrganizerItemPriority>().count() == 1);
     items.append(newContact);
@@ -1278,7 +1278,7 @@ void tst_QOrganizerItemAsync::itemPartialSave()
     QVERIFY(isr.errorMap().isEmpty());
     items = isr.items();
     QCOMPARE(items.size()-1, 4);  // Just check that we are dealing with the item at index 4
-    QOrganizerItemLocalId eId = items[4].localId();
+    QOrganizerItemId eId = items[4].id();
     items[4] = oim->item(eId);
     QCOMPARE(items[4].details<QOrganizerItemEmailAddress>().count(), 0); // not saved
     QCOMPARE(items[4].details<QOrganizerItemPriority>().count(), 1); // saved
@@ -2324,8 +2324,8 @@ QOrganizerManager* tst_QOrganizerItemAsync::prepareModel(const QString& managerU
 
     // XXX TODO: ensure that this is the case:
     // there should be no items in the database.
-    QList<QOrganizerItemLocalId> toRemove = oim->itemIds();
-    foreach (const QOrganizerItemLocalId& removeId, toRemove)
+    QList<QOrganizerItemId> toRemove = oim->itemIds();
+    foreach (const QOrganizerItemId& removeId, toRemove)
         oim->removeItem(removeId);
 
     QOrganizerEvent a, b, c;
diff --git a/tests/auto/qorganizeritemfilter/tst_qorganizeritemfilter.cpp b/tests/auto/qorganizeritemfilter/tst_qorganizeritemfilter.cpp
index 92afa8a704..f2d4aeb53c 100644
--- a/tests/auto/qorganizeritemfilter/tst_qorganizeritemfilter.cpp
+++ b/tests/auto/qorganizeritemfilter/tst_qorganizeritemfilter.cpp
@@ -103,7 +103,10 @@ public:
         BasicItemLocalId* cloned = new BasicItemLocalId(m_id);
         return cloned;
     }
-    QDebug debugStreamOut(QDebug dbg) {
+    QString managerUri() const {
+        return QString::fromLatin1("QOrganizer:basicItem:");
+    }
+    QDebug& debugStreamOut(QDebug& dbg) {
         return dbg << m_id;
     }
     QDataStream& dataStreamOut(QDataStream& out) {
@@ -123,9 +126,9 @@ private:
     uint m_id;
 };
 
-QOrganizerItemLocalId makeId(uint id)
+QOrganizerItemId makeId(uint id)
 {
-    return QOrganizerItemLocalId(new BasicItemLocalId(id));
+    return QOrganizerItemId(new BasicItemLocalId(id));
 }
 
 tst_QOrganizerItemFilter::tst_QOrganizerItemFilter()
@@ -851,19 +854,19 @@ void tst_QOrganizerItemFilter::boringFilters()
 
 void tst_QOrganizerItemFilter::idListFilter()
 {
-    QOrganizerItemLocalIdFilter idf;
+    QOrganizerItemIdFilter idf;
 
     QVERIFY(idf.type() == QOrganizerItemFilter::LocalIdFilter);
 
     QVERIFY(idf.ids().count() == 0);
 
-    QList<QOrganizerItemLocalId> ids;
+    QList<QOrganizerItemId> ids;
     ids << makeId(5) << makeId(6) << makeId(17);
 
     idf.setIds(ids);
     QVERIFY(idf.ids() == ids);
 
-    idf.setIds(QList<QOrganizerItemLocalId>());
+    idf.setIds(QList<QOrganizerItemId>());
     QVERIFY(idf.ids().count() == 0);
 
     /* Test op= */
@@ -871,7 +874,7 @@ void tst_QOrganizerItemFilter::idListFilter()
     QOrganizerItemFilter f = idf;
     QVERIFY(f == idf);
 
-    QOrganizerItemLocalIdFilter idf2 = f;
+    QOrganizerItemIdFilter idf2 = f;
     QVERIFY(idf2 == idf);
     QVERIFY(idf2.ids() == ids);
 
@@ -883,9 +886,9 @@ void tst_QOrganizerItemFilter::idListFilter()
     QVERIFY(idf2 == idf);
 
     QOrganizerItemDetailFilter dfil;
-    QOrganizerItemLocalIdFilter idf3(dfil);
+    QOrganizerItemIdFilter idf3(dfil);
     QVERIFY(idf3.type() == QOrganizerItemFilter::LocalIdFilter); // should be a blank id list filter
-    QOrganizerItemLocalIdFilter idf4(idf);
+    QOrganizerItemIdFilter idf4(idf);
     QVERIFY(idf4 == idf); // should be a copy of idf.
     idf = dfil; // now assign.
     QVERIFY(idf == idf3); // again, should be a blank id list filter.
@@ -1013,15 +1016,15 @@ void tst_QOrganizerItemFilter::canonicalizedFilter_data()
     }
 
     {
-        QOrganizerItemLocalIdFilter qclif;
+        QOrganizerItemIdFilter qclif;
         QTest::newRow("Empty local id filter")
                 << static_cast<QOrganizerItemFilter>(qclif)
                 << static_cast<QOrganizerItemFilter>(invalidFilter);
     }
 
     {
-        QOrganizerItemLocalIdFilter qclif;
-        qclif.setIds(QList<QOrganizerItemLocalId>() << makeId(1) << makeId(2));
+        QOrganizerItemIdFilter qclif;
+        qclif.setIds(QList<QOrganizerItemId>() << makeId(1) << makeId(2));
         QTest::newRow("Normal local id filter")
                 << static_cast<QOrganizerItemFilter>(qclif)
                 << static_cast<QOrganizerItemFilter>(qclif);
diff --git a/tests/auto/qorganizermanager/tst_qorganizermanager.cpp b/tests/auto/qorganizermanager/tst_qorganizermanager.cpp
index b165452a87..ac99e7e109 100644
--- a/tests/auto/qorganizermanager/tst_qorganizermanager.cpp
+++ b/tests/auto/qorganizermanager/tst_qorganizermanager.cpp
@@ -110,7 +110,7 @@ QTM_USE_NAMESPACE
 // to get QFETCH to work with the template expression...
 typedef QMap<QString,QString> tst_QOrganizerManager_QStringMap;
 Q_DECLARE_METATYPE(tst_QOrganizerManager_QStringMap)
-Q_DECLARE_METATYPE(QList<QOrganizerItemLocalId>)
+Q_DECLARE_METATYPE(QList<QOrganizerItemId>)
 
 /* A class that no backend can support */
 class UnsupportedMetatype {
@@ -352,7 +352,7 @@ bool tst_QOrganizerManager::isSuperset(const QOrganizerItem& ca, const QOrganize
 void tst_QOrganizerManager::dumpOrganizerItem(const QOrganizerItem& item)
 {
     QOrganizerManager m;
-    qDebug() << "OrganizerItem: " << item.id().localId() << "(" << item.displayLabel() << ")";
+    qDebug() << "OrganizerItem: " << item.id() << "(" << item.displayLabel() << ")";
     QList<QOrganizerItemDetail> details = item.details();
     foreach(QOrganizerItemDetail d, details) {
         qDebug() << "  " << d.definitionName() << ":";
@@ -362,11 +362,11 @@ void tst_QOrganizerManager::dumpOrganizerItem(const QOrganizerItem& item)
 
 void tst_QOrganizerManager::dumpOrganizerItems(QOrganizerManager *cm)
 {
-    QList<QOrganizerItemLocalId> ids = cm->itemIds();
+    QList<QOrganizerItemId> ids = cm->itemIds();
 
     qDebug() << "There are" << ids.count() << "items in" << cm->managerUri();
 
-    foreach(QOrganizerItemLocalId id, ids) {
+    foreach(QOrganizerItemId id, ids) {
         QOrganizerItem c = cm->item(id);
         dumpOrganizerItem(c);
     }
@@ -449,11 +449,11 @@ void tst_QOrganizerManager::nullIdOperations()
 {
     QFETCH(QString, uri);
     QScopedPointer<QOrganizerManager> cm(new QOrganizerManager("memory"));
-    QVERIFY(!cm->removeItem(QOrganizerItemLocalId()));
+    QVERIFY(!cm->removeItem(QOrganizerItemId()));
     QVERIFY(cm->error() == QOrganizerManager::DoesNotExistError);
 
 
-    QOrganizerItem c = cm->item(QOrganizerItemLocalId());
+    QOrganizerItem c = cm->item(QOrganizerItemId());
     QVERIFY(c.id() == QOrganizerItemId());
     QVERIFY(c.isEmpty());
     QVERIFY(cm->error() == QOrganizerManager::DoesNotExistError);
@@ -474,17 +474,17 @@ void tst_QOrganizerManager::nullIdOperations()
     }
 
     {
-        QOrganizerItemLocalId nullLocalId;
+        QOrganizerItemId nullid;
         QByteArray buffer;
         QDataStream outBufferStream(&buffer, QIODevice::WriteOnly);
-        outBufferStream << nullLocalId;
+        outBufferStream << nullid;
         QVERIFY(buffer.length() > 0);
 
         // cannot stream in local ids; must stream in entire ids.
         //QDataStream inBufferStream(buffer);
-        //QOrganizerItemLocalId id;
+        //QOrganizerItemId id;
         //inBufferStream >> id;
-        //QVERIFY(id == nullLocalId);
+        //QVERIFY(id == nullid);
     }
 
     {
@@ -757,10 +757,10 @@ void tst_QOrganizerManager::add()
     QVERIFY(cm->error() == QOrganizerManager::NoError);
 
     QVERIFY(!item.id().managerUri().isEmpty());
-    QVERIFY(!item.id().localId().isNull());
+    QVERIFY(!item.id().isNull());
     QCOMPARE(cm->itemIds().count(), currCount+1);
 
-    QOrganizerItem added = cm->item(item.id().localId());
+    QOrganizerItem added = cm->item(item.id());
     QVERIFY(added.id() == item.id());
     
     if (!isSuperset(added, item)) {
@@ -776,12 +776,12 @@ void tst_QOrganizerManager::add()
     nonexistentItem.setDisplayLabel("Another note.");
     nonexistentItem.setDescription("This is `another note`'s description");
     QVERIFY(cm->saveItem(&nonexistentItem));       // should work
-    QVERIFY(cm->removeItem(nonexistentItem.id().localId())); // now nonexistentItem has an id which does not exist
+    QVERIFY(cm->removeItem(nonexistentItem.id())); // now nonexistentItem has an id which does not exist
     QVERIFY(!cm->saveItem(&nonexistentItem));      // hence, should fail
     QCOMPARE(cm->error(), QOrganizerManager::DoesNotExistError);
     nonexistentItem.setId(QOrganizerItemId());
     QVERIFY(cm->saveItem(&nonexistentItem));       // after setting id to zero, should save
-    QVERIFY(cm->removeItem(nonexistentItem.id().localId()));
+    QVERIFY(cm->removeItem(nonexistentItem.id()));
 
     // now try adding a "megaevent"
     // - get list of all definitions supported by the manager
@@ -862,7 +862,7 @@ void tst_QOrganizerManager::add()
     }
 
     QVERIFY(cm->saveItem(&megaevent)); // must be able to save since built from definitions.
-    QOrganizerItem retrievedMegaitem = cm->item(megaevent.id().localId());
+    QOrganizerItem retrievedMegaitem = cm->item(megaevent.id());
     if (!isSuperset(retrievedMegaitem, megaevent)) {
         dumpOrganizerItemDifferences(megaevent, retrievedMegaitem);
         QEXPECT_FAIL("mgr='wince'", "Address Display Label mismatch", Continue);
@@ -889,8 +889,8 @@ void tst_QOrganizerManager::addExceptions()
     rrule.setLimit(3);
     event.setRecurrenceRule(rrule);
     QVERIFY(cm->saveItem(&event));
-    QVERIFY(!event.localId().isNull());
-    event = cm->item(event.localId());
+    QVERIFY(!event.id().isNull());
+    event = cm->item(event.id());
     // the guid must be set so when it is exported to iCalendar, the relationship can be represented
     QVERIFY(!event.guid().isEmpty());
 
@@ -902,25 +902,25 @@ void tst_QOrganizerManager::addExceptions()
     QCOMPARE(secondItem.type(), QLatin1String(QOrganizerItemType::TypeEventOccurrence));
     QOrganizerEventOccurrence secondEvent = static_cast<QOrganizerEventOccurrence>(secondItem); // not sure this is the best way...
     QCOMPARE(secondEvent.startDateTime(), QDateTime(QDate(2010, 1, 8), QTime(11, 0, 0)));
-    QCOMPARE(secondEvent.localId(), QOrganizerItemLocalId());
-    QCOMPARE(secondEvent.parentLocalId(), event.localId());
+    QCOMPARE(secondEvent.id(), QOrganizerItemId());
+    QCOMPARE(secondEvent.parentId(), event.id());
 
     // save a change to an occurrence's detail (ie. create an exception)
     secondEvent.setDisplayLabel(QLatin1String("seminar"));
     QVERIFY(cm->saveItem(&secondEvent));
-    event = cm->item(event.localId()); // reload the event to pick up any changed exception dates.
+    event = cm->item(event.id()); // reload the event to pick up any changed exception dates.
     items = cm->itemOccurrences(event, QDateTime(QDate(2010, 1, 1), QTime(0, 0, 0)),
                                      QDateTime(QDate(2010, 2, 1), QTime(0, 0, 0)));
     QCOMPARE(items.size(), 3); // shouldn't change the count.
 
     // save a change to an occurrence's time
     QOrganizerEventOccurrence thirdEvent = static_cast<QOrganizerEventOccurrence>(items.at(2));
-    QCOMPARE(thirdEvent.localId(), QOrganizerItemLocalId());
-    QCOMPARE(thirdEvent.parentLocalId(), event.localId());
+    QCOMPARE(thirdEvent.id(), QOrganizerItemId());
+    QCOMPARE(thirdEvent.parentId(), event.id());
     thirdEvent.setStartDateTime(QDateTime(QDate(2010, 1, 15), QTime(13, 0, 0)));
     thirdEvent.setEndDateTime(QDateTime(QDate(2010, 1, 15), QTime(14, 0, 0)));
     QVERIFY(cm->saveItem(&thirdEvent));
-    event = cm->item(event.localId()); // reload the event to pick up any changed exception dates.
+    event = cm->item(event.id()); // reload the event to pick up any changed exception dates.
     items = cm->itemOccurrences(event, QDateTime(QDate(2010, 1, 1), QTime(0, 0, 0)),
                                      QDateTime(QDate(2010, 2, 1), QTime(0, 0, 0)));
     QCOMPARE(items.size(), 3); // shouldn't change the count.
@@ -930,17 +930,17 @@ void tst_QOrganizerManager::addExceptions()
     bool foundSecond = false;
     bool foundThird = false;
     foreach (const QOrganizerItem& item, items) {
-        if (item.localId().isNull()) {
+        if (item.id().isNull()) {
             foundFirst = true;
             firstItem = item;
         }
 
-        if (item.localId() == secondEvent.localId()) {
+        if (item.id() == secondEvent.id()) {
             foundSecond = true;
             secondEvent = item;
         }
 
-        if (item.localId() == thirdEvent.localId()) {
+        if (item.id() == thirdEvent.id()) {
             foundThird = true;
             thirdEvent = item;
         }
@@ -949,27 +949,27 @@ void tst_QOrganizerManager::addExceptions()
     // check that saving an exception doesn't change other items
     QVERIFY(foundFirst); // there should still be one "generated" occurrence
     QCOMPARE(firstItem.displayLabel(), QLatin1String("meeting")); // and it should have the original label.
-    // item occurrences which are not exceptions should have zero localId
-    QVERIFY(firstItem.localId().isNull());
+    // item occurrences which are not exceptions should have zero id
+    QVERIFY(firstItem.id().isNull());
 
     // the exception's changes have been persisted
     QVERIFY(foundSecond);
     QCOMPARE(secondEvent.displayLabel(), QLatin1String("seminar"));
-    // item occurrences which are persisted exceptions should have non-zero localId
-    QVERIFY(!secondEvent.localId().isNull());
+    // item occurrences which are persisted exceptions should have non-zero id
+    QVERIFY(!secondEvent.id().isNull());
 
     QVERIFY(foundThird);
     QCOMPARE(thirdEvent.startDateTime(), QDateTime(QDate(2010, 1, 15), QTime(13, 0, 0)));
     QCOMPARE(thirdEvent.endDateTime(), QDateTime(QDate(2010, 1, 15), QTime(14, 0, 0)));
-    QVERIFY(!thirdEvent.localId().isNull());
+    QVERIFY(!thirdEvent.id().isNull());
 }
 
 void tst_QOrganizerManager::addExceptionsWithGuid()
 {
     // It should be possible to save an exception that has at least an originalDate and either a
-    // guid or a parentLocalId.  If guid and parentLocalId are both specified, the client should
+    // guid or a parentId.  If guid and parentId are both specified, the client should
     // ensure they are consistent and the manager should fail if they are not.  If only one of the
-    // guid or parentLocalId are specified, the manager should generate the other one.
+    // guid or parentId are specified, the manager should generate the other one.
     // This test case tests all of this.
     QFETCH(QString, uri);
     QScopedPointer<QOrganizerManager> cm(QOrganizerManager::fromUri(uri));
@@ -985,7 +985,7 @@ void tst_QOrganizerManager::addExceptionsWithGuid()
     christmas.setRecurrenceRule(rrule);
     QVERIFY(cm->saveItem(&christmas));
     QVERIFY(!christmas.id().managerUri().isEmpty());
-    QVERIFY(!christmas.id().localId().isNull());
+    QVERIFY(!christmas.id().isNull());
 
     QOrganizerEvent newYearsDay;
     newYearsDay.setGuid("newyear");
@@ -1023,15 +1023,15 @@ void tst_QOrganizerManager::addExceptionsWithGuid()
     exception.setId(QOrganizerItemId());
     exception.setGuid(QLatin1String("christmas"));
     QVERIFY(cm->saveItem(&exception));
-    QVERIFY(!exception.localId().isNull());
-    QOrganizerEventOccurrence savedException = cm->item(exception.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId()); // parentLocalId should be set by manager
+    QVERIFY(!exception.id().isNull());
+    QOrganizerEventOccurrence savedException = cm->item(exception.id());
+    QCOMPARE(savedException.parentId(), christmas.id()); // parentId should be set by manager
 
-    // with the localId, guid and the parentId all set and consistent, it should work
+    // with the id, guid and the parentId all set and consistent, it should work
     exception = savedException;
     QVERIFY(cm->saveItem(&exception));
-    savedException = cm->item(exception.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId());
+    savedException = cm->item(exception.id());
+    QCOMPARE(savedException.parentId(), christmas.id());
 
     // Make a fresh exception object on a fresh date to avoid clashing with the previously saved one
     // can't set parentId to a non-event
@@ -1042,18 +1042,18 @@ void tst_QOrganizerManager::addExceptionsWithGuid()
     exception2.setDisplayLabel(QLatin1String("XMas"));
     if (cm->detailDefinitions(QOrganizerItemType::TypeEventOccurrence).contains(QOrganizerItemComment::DefinitionName))
         exception2.addComment(QLatin1String("With the in-laws"));
-    exception2.setParentLocalId(report.localId()); // report is not an event
+    exception2.setParentId(report.id()); // report is not an event
     QVERIFY(!cm->saveItem(&exception2));
     QCOMPARE(cm->error(), QOrganizerManager::InvalidOccurrenceError);
 
     // can't set guid to a non-event
     exception2.setGuid(QLatin1String("report"));
-    exception2.setParentLocalId(QOrganizerItemLocalId());
+    exception2.setParentId(QOrganizerItemId());
     QVERIFY(!cm->saveItem(&exception2));
     QCOMPARE(cm->error(), QOrganizerManager::InvalidOccurrenceError);
 
     // can't make the guid inconsistent with the parentId
-    exception2.setParentLocalId(christmas.localId());
+    exception2.setParentId(christmas.id());
     exception2.setGuid(QLatin1String("newyear"));
     QVERIFY(!cm->saveItem(&exception2));
     QCOMPARE(cm->error(), QOrganizerManager::InvalidOccurrenceError);
@@ -1061,8 +1061,8 @@ void tst_QOrganizerManager::addExceptionsWithGuid()
     // with just the parentId set to a valid parent, it should work
     exception2.setGuid(QLatin1String(""));
     QVERIFY(cm->saveItem(&exception2));
-    savedException = cm->item(exception2.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId());
+    savedException = cm->item(exception2.id());
+    QCOMPARE(savedException.parentId(), christmas.id());
     QCOMPARE(savedException.guid(), QLatin1String("christmas")); // guid should be set by manager
 
     // Make a fresh exception object on a fresh date to avoid clashing with the previously saved one
@@ -1073,17 +1073,17 @@ void tst_QOrganizerManager::addExceptionsWithGuid()
     exception3.setDisplayLabel(QLatin1String("XMas"));
     if (cm->detailDefinitions(QOrganizerItemType::TypeEventOccurrence).contains(QOrganizerItemComment::DefinitionName))
         exception3.addComment(QLatin1String("With the in-laws"));
-    exception3.setParentLocalId(christmas.localId());
+    exception3.setParentId(christmas.id());
     exception3.setGuid(QLatin1String("christmas"));
     QVERIFY(!cm->saveItem(&exception3));
     QCOMPARE(cm->error(), QOrganizerManager::InvalidOccurrenceError);
 
-    // with original date, guid and parentId set and consistent, and localId=0, it should work
+    // with original date, guid and parentId set and consistent, and id=0, it should work
     exception3.setOriginalDate(QDate(2012, 12, 25));
     QVERIFY(cm->saveItem(&exception3));
-    QVERIFY(!exception3.localId().isNull());
-    savedException = cm->item(exception3.localId());
-    QCOMPARE(savedException.parentLocalId(), christmas.localId());
+    QVERIFY(!exception3.id().isNull());
+    savedException = cm->item(exception3.id());
+    QCOMPARE(savedException.parentId(), christmas.id());
 }
 
 void tst_QOrganizerManager::update()
@@ -1118,7 +1118,7 @@ void tst_QOrganizerManager::update()
     item.saveDetail(&descr);
     QVERIFY(cm->saveItem(&item));
     QVERIFY(cm->error() == QOrganizerManager::NoError);
-    QOrganizerItem updated = cm->item(item.localId());
+    QOrganizerItem updated = cm->item(item.id());
     QOrganizerItemDescription updatedDescr = updated.detail(QOrganizerItemDescription::DefinitionName);
     QCOMPARE(updatedDescr, descr);
 }
@@ -1148,9 +1148,9 @@ void tst_QOrganizerManager::remove()
 
     /* Remove the created item */
     const int itemCount = cm->itemIds().count();
-    QVERIFY(cm->removeItem(item.localId()));
+    QVERIFY(cm->removeItem(item.id()));
     QCOMPARE(cm->itemIds().count(), itemCount - 1);
-    QVERIFY(cm->item(item.localId()).isEmpty());
+    QVERIFY(cm->item(item.id()).isEmpty());
     QCOMPARE(cm->error(), QOrganizerManager::DoesNotExistError);
 }
 
@@ -1163,7 +1163,7 @@ void tst_QOrganizerManager::batch()
     QVERIFY(!cm->saveItems(NULL));
     QVERIFY(cm->error() == QOrganizerManager::BadArgumentError);
 
-    QVERIFY(!cm->removeItems(QList<QOrganizerItemLocalId>()));
+    QVERIFY(!cm->removeItems(QList<QOrganizerItemId>()));
     QVERIFY(cm->error() == QOrganizerManager::BadArgumentError);
     
     // Use note & todo item depending on backend support
@@ -1217,9 +1217,9 @@ void tst_QOrganizerManager::batch()
     QVERIFY(items.at(2).detail(QOrganizerItemDisplayLabel::DefinitionName) == dc);
 
     /* Retrieve again */
-    a = cm->item(items.at(0).id().localId());
-    b = cm->item(items.at(1).id().localId());
-    c = cm->item(items.at(2).id().localId());
+    a = cm->item(items.at(0).id());
+    b = cm->item(items.at(1).id());
+    c = cm->item(items.at(2).id());
     QVERIFY(items.at(0).detail(QOrganizerItemDisplayLabel::DefinitionName) == da);
     QVERIFY(items.at(1).detail(QOrganizerItemDisplayLabel::DefinitionName) == db);
     QVERIFY(items.at(2).detail(QOrganizerItemDisplayLabel::DefinitionName) == dc);
@@ -1240,9 +1240,9 @@ void tst_QOrganizerManager::batch()
     QVERIFY(errorMap.count() == 0);
 
     /* Retrieve them and check them again */
-    a = cm->item(items.at(0).id().localId());
-    b = cm->item(items.at(1).id().localId());
-    c = cm->item(items.at(2).id().localId());
+    a = cm->item(items.at(0).id());
+    b = cm->item(items.at(1).id());
+    c = cm->item(items.at(2).id());
     QVERIFY(items.at(0).detail(QOrganizerItemDisplayLabel::DefinitionName) == da);
     QVERIFY(items.at(1).detail(QOrganizerItemDisplayLabel::DefinitionName) == db);
     QVERIFY(items.at(2).detail(QOrganizerItemDisplayLabel::DefinitionName) == dc);
@@ -1256,27 +1256,27 @@ void tst_QOrganizerManager::batch()
     QVERIFY(c.details<QOrganizerItemDescription>().at(0).description() == "This note is a terrible note");
 
     /* Now delete them all */
-    QList<QOrganizerItemLocalId> ids;
-    ids << a.id().localId() << b.id().localId() << c.id().localId();
+    QList<QOrganizerItemId> ids;
+    ids << a.id() << b.id() << c.id();
     QVERIFY(cm->removeItems(ids));
     errorMap = cm->errorMap();
     QVERIFY(errorMap.count() == 0);
     QVERIFY(cm->error() == QOrganizerManager::NoError);
 
     /* Make sure the items really don't exist any more */
-    QVERIFY(cm->item(a.id().localId()).id() == QOrganizerItemId());
-    QVERIFY(cm->item(a.id().localId()).isEmpty());
+    QVERIFY(cm->item(a.id()).id() == QOrganizerItemId());
+    QVERIFY(cm->item(a.id()).isEmpty());
     QVERIFY(cm->error() == QOrganizerManager::DoesNotExistError);
-    QVERIFY(cm->item(b.id().localId()).id() == QOrganizerItemId());
-    QVERIFY(cm->item(b.id().localId()).isEmpty());
+    QVERIFY(cm->item(b.id()).id() == QOrganizerItemId());
+    QVERIFY(cm->item(b.id()).isEmpty());
     QVERIFY(cm->error() == QOrganizerManager::DoesNotExistError);
-    QVERIFY(cm->item(c.id().localId()).id() == QOrganizerItemId());
-    QVERIFY(cm->item(c.id().localId()).isEmpty());
+    QVERIFY(cm->item(c.id()).id() == QOrganizerItemId());
+    QVERIFY(cm->item(c.id()).isEmpty());
     QVERIFY(cm->error() == QOrganizerManager::DoesNotExistError);
 
     /* Now try removing with all invalid ids (e.g. the ones we just removed) */
     ids.clear();
-    ids << a.id().localId() << b.id().localId() << c.id().localId();
+    ids << a.id() << b.id() << c.id();
     QVERIFY(!cm->removeItems(ids));
     QVERIFY(cm->error() == QOrganizerManager::DoesNotExistError);
     errorMap = cm->errorMap();
@@ -1338,14 +1338,14 @@ void tst_QOrganizerManager::batch()
     d.setType(type);
     d.setDisplayLabel("XXXXXX D Note");
     QVERIFY(cm->saveItem(&d));
-    QOrganizerItemLocalId removedId = d.localId();
+    QOrganizerItemId removedId = d.id();
     QVERIFY(cm->removeItem(removedId));
 
     /* Now delete 3 items, but with one bad argument */
     ids.clear();
-    ids << items.at(0).id().localId();
+    ids << items.at(0).id();
     ids << removedId;
-    ids << items.at(2).id().localId();
+    ids << items.at(2).id();
 
     QVERIFY(!cm->removeItems(ids));
     QVERIFY(cm->error() != QOrganizerManager::NoError);
@@ -1402,11 +1402,11 @@ void tst_QOrganizerManager::invalidManager()
     QVERIFY(foo.id() == QOrganizerItemId());
     QVERIFY(manager.itemIds().count() == 0);
 
-    QVERIFY(manager.item(foo.id().localId()).id() == QOrganizerItemId());
-    QVERIFY(manager.item(foo.id().localId()).isEmpty());
+    QVERIFY(manager.item(foo.id()).id() == QOrganizerItemId());
+    QVERIFY(manager.item(foo.id()).isEmpty());
     QVERIFY(manager.error() == QOrganizerManager::NotSupportedError);
 
-    QVERIFY(manager.removeItem(foo.id().localId()) == false);
+    QVERIFY(manager.removeItem(foo.id()) == false);
     QVERIFY(manager.error() == QOrganizerManager::NotSupportedError);
 
     QMap<int, QOrganizerManager::Error> errorMap;
@@ -1440,13 +1440,13 @@ void tst_QOrganizerManager::invalidManager()
     QVERIFY(errorMap.count() == 0);
     QVERIFY(manager.error() == QOrganizerManager::NotSupportedError);
 
-    QVERIFY(!manager.removeItems(QList<QOrganizerItemLocalId>()));
+    QVERIFY(!manager.removeItems(QList<QOrganizerItemId>()));
     errorMap = manager.errorMap();
     QVERIFY(errorMap.count() == 0);
     QVERIFY(manager.error() == QOrganizerManager::BadArgumentError);
 
-    QList<QOrganizerItemLocalId> idlist;
-    idlist << foo.id().localId();
+    QList<QOrganizerItemId> idlist;
+    idlist << foo.id();
     QVERIFY(!manager.removeItems(idlist));
     errorMap = manager.errorMap();
     QVERIFY(errorMap.count() == 0);
@@ -1529,7 +1529,7 @@ void tst_QOrganizerManager::memoryManager()
     QCOMPARE(m5.itemIds().count(), 0);
 
     // remove c2 from m2 - ensure that this doesn't affect any other manager.
-    m2.removeItem(c2.id().localId());
+    m2.removeItem(c2.id());
     QCOMPARE(m1.itemIds().count(), 1);
     QCOMPARE(m2.itemIds().count(), 1);
     QCOMPARE(m3.itemIds().count(), 1);
@@ -1544,7 +1544,7 @@ void tst_QOrganizerManager::memoryManager()
     QVERIFY(m3.item(m3.itemIds().at(0)) == m4.item(m4.itemIds().at(0)));
 
     // now, we should be able to remove from m4, and have m3 empty
-    QVERIFY(m4.removeItem(c.id().localId()));
+    QVERIFY(m4.removeItem(c.id()));
     QCOMPARE(m3.itemIds().count(), 0);
     QCOMPARE(m4.itemIds().count(), 0);
     QCOMPARE(m5.itemIds().count(), 0);
@@ -1973,18 +1973,18 @@ void tst_QOrganizerManager::signalEmission()
     QFETCH(QString, uri);
     QScopedPointer<QOrganizerManager> m1(QOrganizerManager::fromUri(uri));
 
-    qRegisterMetaType<QOrganizerItemLocalId>("QOrganizerItemLocalId");
-    qRegisterMetaType<QList<QOrganizerItemLocalId> >("QList<QOrganizerItemLocalId>");
-    QSignalSpy spyCA(m1.data(), SIGNAL(itemsAdded(QList<QOrganizerItemLocalId>)));
-    QSignalSpy spyCM(m1.data(), SIGNAL(itemsChanged(QList<QOrganizerItemLocalId>)));
-    QSignalSpy spyCR(m1.data(), SIGNAL(itemsRemoved(QList<QOrganizerItemLocalId>)));
+    qRegisterMetaType<QOrganizerItemId>("QOrganizerItemId");
+    qRegisterMetaType<QList<QOrganizerItemId> >("QList<QOrganizerItemId>");
+    QSignalSpy spyCA(m1.data(), SIGNAL(itemsAdded(QList<QOrganizerItemId>)));
+    QSignalSpy spyCM(m1.data(), SIGNAL(itemsChanged(QList<QOrganizerItemId>)));
+    QSignalSpy spyCR(m1.data(), SIGNAL(itemsRemoved(QList<QOrganizerItemId>)));
 
     QList<QVariant> args;
-    QList<QOrganizerItemLocalId> arg;
+    QList<QOrganizerItemId> arg;
     QOrganizerTodo todo;
     QList<QOrganizerItem> batchAdd;
-    QList<QOrganizerItemLocalId> batchRemove;
-    QList<QOrganizerItemLocalId> sigids;
+    QList<QOrganizerItemId> batchRemove;
+    QList<QOrganizerItemId> sigids;
     int addSigCount = 0; // the expected signal counts.
     int modSigCount = 0;
     int remSigCount = 0;
@@ -1994,14 +1994,14 @@ void tst_QOrganizerManager::signalEmission()
     nc.setLabel("label me this");
     QVERIFY(todo.saveDetail(&nc));
     QVERIFY(m1->saveItem(&todo));
-    QOrganizerItemLocalId cid = todo.id().localId();
+    QOrganizerItemId cid = todo.id();
     addSigCount += 1;
     QTRY_COMPARE(spyCA.count(), addSigCount);
     args = spyCA.takeFirst();
     addSigCount -= 1;
-    arg = args.first().value<QList<QOrganizerItemLocalId> >();
+    arg = args.first().value<QList<QOrganizerItemId> >();
     QVERIFY(arg.count() == 1);
-    QCOMPARE(QOrganizerItemLocalId(arg.at(0)), cid);
+    QCOMPARE(QOrganizerItemId(arg.at(0)), cid);
 
     // verify save modified emits signal changed
     nc.setLabel("label me that");
@@ -2011,19 +2011,19 @@ void tst_QOrganizerManager::signalEmission()
     QTRY_COMPARE(spyCM.count(), modSigCount);
     args = spyCM.takeFirst();
     modSigCount -= 1;
-    arg = args.first().value<QList<QOrganizerItemLocalId> >();
+    arg = args.first().value<QList<QOrganizerItemId> >();
     QVERIFY(arg.count() == 1);
-    QCOMPARE(QOrganizerItemLocalId(arg.at(0)), cid);
+    QCOMPARE(QOrganizerItemId(arg.at(0)), cid);
 
     // verify remove emits signal removed
-    QVERIFY(m1->removeItem(todo.id().localId()));
+    QVERIFY(m1->removeItem(todo.id()));
     remSigCount += 1;
     QTRY_COMPARE(spyCR.count(), remSigCount);
     args = spyCR.takeFirst();
     remSigCount -= 1;
-    arg = args.first().value<QList<QOrganizerItemLocalId> >();
+    arg = args.first().value<QList<QOrganizerItemId> >();
     QVERIFY(arg.count() == 1);
-    QCOMPARE(QOrganizerItemLocalId(arg.at(0)), cid);
+    QCOMPARE(QOrganizerItemId(arg.at(0)), cid);
 
     // verify multiple adds works as advertised
     QOrganizerTodo todo2, todo3;
@@ -2055,13 +2055,13 @@ void tst_QOrganizerManager::signalEmission()
     QTRY_COMPARE(spyCM.count(), modSigCount);
 
     // verify multiple removes works as advertised
-    m1->removeItem(todo3.id().localId());
+    m1->removeItem(todo3.id());
     remSigCount += 1;
-    m1->removeItem(todo2.id().localId());
+    m1->removeItem(todo2.id());
     remSigCount += 1;
     QTRY_COMPARE(spyCR.count(), remSigCount);
 
-    QVERIFY(!m1->removeItem(todo.id().localId())); // not saved.
+    QVERIFY(!m1->removeItem(todo.id())); // not saved.
 
     /* Now test the batch equivalents */
     spyCA.clear();
@@ -2085,7 +2085,7 @@ void tst_QOrganizerManager::signalEmission()
     /* We basically loop, processing events, until we've seen an Add signal for each item */
     sigids.clear();
 
-    QTRY_WAIT( while(spyCA.size() > 0) {sigids += spyCA.takeFirst().at(0).value<QList<QOrganizerItemLocalId> >(); }, sigids.contains(todo.localId()) && sigids.contains(todo2.localId()) && sigids.contains(todo3.localId()));
+    QTRY_WAIT( while(spyCA.size() > 0) {sigids += spyCA.takeFirst().at(0).value<QList<QOrganizerItemId> >(); }, sigids.contains(todo.id()) && sigids.contains(todo2.id()) && sigids.contains(todo3.id()));
     QTRY_COMPARE(spyCM.count(), 0);
     QTRY_COMPARE(spyCR.count(), 0);
 
@@ -2103,15 +2103,15 @@ void tst_QOrganizerManager::signalEmission()
     errorMap = m1->errorMap();
 
     sigids.clear();
-    QTRY_WAIT( while(spyCM.size() > 0) {sigids += spyCM.takeFirst().at(0).value<QList<QOrganizerItemLocalId> >(); }, sigids.contains(todo.localId()) && sigids.contains(todo2.localId()) && sigids.contains(todo3.localId()));
+    QTRY_WAIT( while(spyCM.size() > 0) {sigids += spyCM.takeFirst().at(0).value<QList<QOrganizerItemId> >(); }, sigids.contains(todo.id()) && sigids.contains(todo2.id()) && sigids.contains(todo3.id()));
 
     /* Batch removes */
-    batchRemove << todo.id().localId() << todo2.id().localId() << todo3.id().localId();
+    batchRemove << todo.id() << todo2.id() << todo3.id();
     QVERIFY(m1->removeItems(batchRemove));
     errorMap = m1->errorMap();
 
     sigids.clear();
-    QTRY_WAIT( while(spyCR.size() > 0) {sigids += spyCR.takeFirst().at(0).value<QList<QOrganizerItemLocalId> >(); }, sigids.contains(todo.localId()) && sigids.contains(todo2.localId()) && sigids.contains(todo3.localId()));
+    QTRY_WAIT( while(spyCR.size() > 0) {sigids += spyCR.takeFirst().at(0).value<QList<QOrganizerItemId> >(); }, sigids.contains(todo.id()) && sigids.contains(todo2.id()) && sigids.contains(todo3.id()));
 
     QTRY_COMPARE(spyCA.count(), 0);
     QTRY_COMPARE(spyCM.count(), 0);
@@ -2133,7 +2133,7 @@ void tst_QOrganizerManager::signalEmission()
         QVERIFY(m2->saveItem(&todo));
         QTRY_COMPARE(spyCA.count(), 1); // check that we received the update signals.
         QTRY_COMPARE(spyCM.count(), 1); // check that we received the update signals.
-        m2->removeItem(todo.localId());
+        m2->removeItem(todo.id());
         QTRY_COMPARE(spyCR.count(), 1); // check that we received the remove signal.
     }
 }
@@ -2148,7 +2148,7 @@ void tst_QOrganizerManager::errorStayingPut()
     QVERIFY(m1.error() == QOrganizerManager::NoError);
 
     /* Remove an invalid item to get an error */
-    QVERIFY(m1.removeItem(QOrganizerItemLocalId()) == false);
+    QVERIFY(m1.removeItem(QOrganizerItemId()) == false);
     QVERIFY(m1.error() == QOrganizerManager::DoesNotExistError);
 
     /* Create a new manager with hopefully the same backend */
@@ -2391,7 +2391,7 @@ void tst_QOrganizerManager::detailDefinitions()
 
 void tst_QOrganizerManager::changeSet()
 {
-    QOrganizerItemLocalId id;
+    QOrganizerItemId id;
 
     QOrganizerItemChangeSet changeSet;
     QVERIFY(changeSet.addedItems().isEmpty());
@@ -2405,7 +2405,7 @@ void tst_QOrganizerManager::changeSet()
     QVERIFY(changeSet.addedItems().contains(id));
 
     changeSet.insertChangedItem(id);
-    changeSet.insertChangedItems(QList<QOrganizerItemLocalId>() << id);
+    changeSet.insertChangedItems(QList<QOrganizerItemId>() << id);
     QVERIFY(changeSet.changedItems().size() == 1); // set, should only be added once.
     QVERIFY(!changeSet.addedItems().isEmpty());
     QVERIFY(!changeSet.changedItems().isEmpty());
@@ -2414,7 +2414,7 @@ void tst_QOrganizerManager::changeSet()
     changeSet.clearChangedItems();
     QVERIFY(changeSet.changedItems().isEmpty());
 
-    changeSet.insertRemovedItems(QList<QOrganizerItemLocalId>() << id);
+    changeSet.insertRemovedItems(QList<QOrganizerItemId>() << id);
     QVERIFY(changeSet.removedItems().contains(id));
     changeSet.clearRemovedItems();
     QVERIFY(changeSet.removedItems().isEmpty());
@@ -2592,7 +2592,7 @@ void tst_QOrganizerManager::recurrence()
     items = cm->items(QDateTime(QDate(2012, 8, 10), QTime(0,0,0)), QDateTime(QDate(2012, 8, 10), QTime(23,59,59)));
     QCOMPARE(items.count(), 1);
     QOrganizerItem item = items.at(0);
-    QVERIFY(!item.localId().isNull());
+    QVERIFY(!item.id().isNull());
     QVERIFY(item.type() == QOrganizerItemType::TypeEventOccurrence);
 
     // Add a normal event to the first day
@@ -2607,12 +2607,12 @@ void tst_QOrganizerManager::recurrence()
     QCOMPARE(items.count(), 4);
     foreach(QOrganizerItem item, items) {
         // check if the item is the recurrence exception
-        if (item.localId() == ex.localId()) {
+        if (item.id() == ex.id()) {
             QOrganizerEventOccurrence exc = static_cast<QOrganizerEventOccurrence>(item);
             QCOMPARE(exc.guid(), ex.guid());
             QCOMPARE(exc.startDateTime(), ex.startDateTime());
             QCOMPARE(exc.endDateTime(), ex.endDateTime());
-        } else if (item.localId() == event2.localId()) {
+        } else if (item.id() == event2.id()) {
             // check if the item is the normal event
             QOrganizerEvent ev = static_cast<QOrganizerEvent>(item);
             QCOMPARE(ev.guid(), event2.guid());
@@ -2621,7 +2621,7 @@ void tst_QOrganizerManager::recurrence()
         } else {
             // item must be event occurrence type and has to be a generated one
             QVERIFY(item.type() == QOrganizerItemType::TypeEventOccurrence);
-            QVERIFY(item.localId().isNull());
+            QVERIFY(item.id().isNull());
         }
     }
 
@@ -2737,20 +2737,20 @@ void tst_QOrganizerManager::detailOrders()
     a.saveDetail(&comment3);
 
     QVERIFY(cm->saveItem(&a));
-    a = cm->item(a.id().localId());
+    a = cm->item(a.id());
     
     QList<QOrganizerItemDetail> details = a.details(QOrganizerItemComment::DefinitionName);
     QVERIFY(details.count() == 3);
     
     QVERIFY(a.removeDetail(&comment2));
     QVERIFY(cm->saveItem(&a));
-    a = cm->item(a.id().localId());
+    a = cm->item(a.id());
     details = a.details(QOrganizerItemComment::DefinitionName);
     QVERIFY(details.count() == 2);
 
     a.saveDetail(&comment2);
     QVERIFY(cm->saveItem(&a));
-    a = cm->item(a.id().localId());
+    a = cm->item(a.id());
     
     details = a.details(QOrganizerItemComment::DefinitionName);
     QVERIFY(details.count() == 3);
@@ -2767,20 +2767,20 @@ void tst_QOrganizerManager::detailOrders()
     a.saveDetail(&address3);
 
     QVERIFY(cm->saveItem(&a));
-    a = cm->item(a.id().localId());
+    a = cm->item(a.id());
     
     details = a.details(QOrganizerItemLocation::DefinitionName);
     QVERIFY(details.count() == 1); // 1 location - they're unique
 
     QVERIFY(a.removeDetail(&address3)); // remove the most recent.
     QVERIFY(cm->saveItem(&a));
-    a = cm->item(a.id().localId());
+    a = cm->item(a.id());
     details = a.details(QOrganizerItemLocation::DefinitionName);
     QVERIFY(details.count() == 0); // unique, remove one means none left.
 
     a.saveDetail(&address2);
     QVERIFY(cm->saveItem(&a));
-    a = cm->item(a.id().localId());
+    a = cm->item(a.id());
     
     details = a.details(QOrganizerItemLocation::DefinitionName);
     QVERIFY(details.count() == 1); // add one back.
diff --git a/tests/auto/qorganizermanagerdataholder.h b/tests/auto/qorganizermanagerdataholder.h
index 101d8a7330..3508b778e2 100644
--- a/tests/auto/qorganizermanagerdataholder.h
+++ b/tests/auto/qorganizermanagerdataholder.h
@@ -82,9 +82,9 @@ public:
                 qDebug() << "Saving items for" << mgrUri;
                 QList<QOrganizerItem> items = cm->itemsForExport(QDateTime(), QDateTime(), QOrganizerItemFilter());
                 savedItems.insert(cm->managerName(),items);
-                QList<QOrganizerItemLocalId> ids;
+                QList<QOrganizerItemId> ids;
                 foreach(const QOrganizerItem& item, items)
-                    ids.append(item.localId());
+                    ids.append(item.id());
                 cm->removeItems(ids);
                 delete cm;
             }