Adjust codegeneration to emit simpler classes

core/src/DTO/accessschedule.cpp

@@ -29,55 +29,61 @@
 
 #include <JellyfinQt/DTO/accessschedule.h>
 
-#include <JellyfinQt/DTO/dynamicdayofweek.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-AccessSchedule::AccessSchedule(QObject *parent) : QObject(parent) {}
+AccessSchedule::AccessSchedule(QObject *parent) {}
 
-AccessSchedule *AccessSchedule::fromJSON(QJsonObject source, QObject *parent) {
-	AccessSchedule *instance = new AccessSchedule(parent);
-	instance->updateFromJSON(source);
+AccessSchedule AccessSchedule::fromJson(QJsonObject source) {AccessSchedule instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AccessSchedule::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AccessSchedule::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<qint32>(source["Id"]);
+	m_userId = fromJsonValue<QUuid>(source["UserId"]);
+	m_dayOfWeek = fromJsonValue<DynamicDayOfWeek>(source["DayOfWeek"]);
+	m_startHour = fromJsonValue<double>(source["StartHour"]);
+	m_endHour = fromJsonValue<double>(source["EndHour"]);
+
 }
-QJsonObject AccessSchedule::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AccessSchedule::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<qint32>(m_jellyfinId);
+	result["UserId"] = toJsonValue<QUuid>(m_userId);
+	result["DayOfWeek"] = toJsonValue<DynamicDayOfWeek>(m_dayOfWeek);
+	result["StartHour"] = toJsonValue<double>(m_startHour);
+	result["EndHour"] = toJsonValue<double>(m_endHour);
+
 	return result;
 }
+
 qint32 AccessSchedule::jellyfinId() const { return m_jellyfinId; }
+
 void AccessSchedule::setJellyfinId(qint32 newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
+QUuid AccessSchedule::userId() const { return m_userId; }
 
-QString AccessSchedule::userId() const { return m_userId; }
-void AccessSchedule::setUserId(QString newUserId) {
+void AccessSchedule::setUserId(QUuid newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 DynamicDayOfWeek AccessSchedule::dayOfWeek() const { return m_dayOfWeek; }
+
 void AccessSchedule::setDayOfWeek(DynamicDayOfWeek newDayOfWeek) {
 	m_dayOfWeek = newDayOfWeek;
-	emit dayOfWeekChanged(newDayOfWeek);
 }
-
 double AccessSchedule::startHour() const { return m_startHour; }
+
 void AccessSchedule::setStartHour(double newStartHour) {
 	m_startHour = newStartHour;
-	emit startHourChanged(newStartHour);
 }
-
 double AccessSchedule::endHour() const { return m_endHour; }
+
 void AccessSchedule::setEndHour(double newEndHour) {
 	m_endHour = newEndHour;
-	emit endHourChanged(newEndHour);
 }
 
 

core/src/DTO/activitylogentry.cpp

@@ -29,85 +29,96 @@
 
 #include <JellyfinQt/DTO/activitylogentry.h>
 
-#include <JellyfinQt/DTO/loglevel.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ActivityLogEntry::ActivityLogEntry(QObject *parent) : QObject(parent) {}
+ActivityLogEntry::ActivityLogEntry(QObject *parent) {}
 
-ActivityLogEntry *ActivityLogEntry::fromJSON(QJsonObject source, QObject *parent) {
-	ActivityLogEntry *instance = new ActivityLogEntry(parent);
-	instance->updateFromJSON(source);
+ActivityLogEntry ActivityLogEntry::fromJson(QJsonObject source) {ActivityLogEntry instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ActivityLogEntry::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ActivityLogEntry::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<qint64>(source["Id"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_overview = fromJsonValue<QString>(source["Overview"]);
+	m_shortOverview = fromJsonValue<QString>(source["ShortOverview"]);
+	m_type = fromJsonValue<QString>(source["Type"]);
+	m_itemId = fromJsonValue<QString>(source["ItemId"]);
+	m_date = fromJsonValue<QDateTime>(source["Date"]);
+	m_userId = fromJsonValue<QUuid>(source["UserId"]);
+	m_userPrimaryImageTag = fromJsonValue<QString>(source["UserPrimaryImageTag"]);
+	m_severity = fromJsonValue<LogLevel>(source["Severity"]);
+
 }
-QJsonObject ActivityLogEntry::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ActivityLogEntry::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<qint64>(m_jellyfinId);
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Overview"] = toJsonValue<QString>(m_overview);
+	result["ShortOverview"] = toJsonValue<QString>(m_shortOverview);
+	result["Type"] = toJsonValue<QString>(m_type);
+	result["ItemId"] = toJsonValue<QString>(m_itemId);
+	result["Date"] = toJsonValue<QDateTime>(m_date);
+	result["UserId"] = toJsonValue<QUuid>(m_userId);
+	result["UserPrimaryImageTag"] = toJsonValue<QString>(m_userPrimaryImageTag);
+	result["Severity"] = toJsonValue<LogLevel>(m_severity);
+
 	return result;
 }
+
 qint64 ActivityLogEntry::jellyfinId() const { return m_jellyfinId; }
+
 void ActivityLogEntry::setJellyfinId(qint64 newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString ActivityLogEntry::name() const { return m_name; }
+
 void ActivityLogEntry::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ActivityLogEntry::overview() const { return m_overview; }
+
 void ActivityLogEntry::setOverview(QString newOverview) {
 	m_overview = newOverview;
-	emit overviewChanged(newOverview);
 }
-
 QString ActivityLogEntry::shortOverview() const { return m_shortOverview; }
+
 void ActivityLogEntry::setShortOverview(QString newShortOverview) {
 	m_shortOverview = newShortOverview;
-	emit shortOverviewChanged(newShortOverview);
 }
-
 QString ActivityLogEntry::type() const { return m_type; }
+
 void ActivityLogEntry::setType(QString newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 QString ActivityLogEntry::itemId() const { return m_itemId; }
+
 void ActivityLogEntry::setItemId(QString newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QDateTime ActivityLogEntry::date() const { return m_date; }
+
 void ActivityLogEntry::setDate(QDateTime newDate) {
 	m_date = newDate;
-	emit dateChanged(newDate);
 }
+QUuid ActivityLogEntry::userId() const { return m_userId; }
 
-QString ActivityLogEntry::userId() const { return m_userId; }
-void ActivityLogEntry::setUserId(QString newUserId) {
+void ActivityLogEntry::setUserId(QUuid newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 QString ActivityLogEntry::userPrimaryImageTag() const { return m_userPrimaryImageTag; }
+
 void ActivityLogEntry::setUserPrimaryImageTag(QString newUserPrimaryImageTag) {
 	m_userPrimaryImageTag = newUserPrimaryImageTag;
-	emit userPrimaryImageTagChanged(newUserPrimaryImageTag);
 }
-
 LogLevel ActivityLogEntry::severity() const { return m_severity; }
+
 void ActivityLogEntry::setSeverity(LogLevel newSeverity) {
 	m_severity = newSeverity;
-	emit severityChanged(newSeverity);
 }
 
 

core/src/DTO/activitylogentryqueryresult.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-ActivityLogEntryQueryResult::ActivityLogEntryQueryResult(QObject *parent) : QObject(parent) {}
+ActivityLogEntryQueryResult::ActivityLogEntryQueryResult(QObject *parent) {}
 
-ActivityLogEntryQueryResult *ActivityLogEntryQueryResult::fromJSON(QJsonObject source, QObject *parent) {
-	ActivityLogEntryQueryResult *instance = new ActivityLogEntryQueryResult(parent);
-	instance->updateFromJSON(source);
+ActivityLogEntryQueryResult ActivityLogEntryQueryResult::fromJson(QJsonObject source) {ActivityLogEntryQueryResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ActivityLogEntryQueryResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ActivityLogEntryQueryResult::setFromJson(QJsonObject source) {
+	m_items = fromJsonValue<QList<QSharedPointer<ActivityLogEntry>>>(source["Items"]);
+	m_totalRecordCount = fromJsonValue<qint32>(source["TotalRecordCount"]);
+	m_startIndex = fromJsonValue<qint32>(source["StartIndex"]);
+
 }
-QJsonObject ActivityLogEntryQueryResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ActivityLogEntryQueryResult::toJson() {
 	QJsonObject result;
+	result["Items"] = toJsonValue<QList<QSharedPointer<ActivityLogEntry>>>(m_items);
+	result["TotalRecordCount"] = toJsonValue<qint32>(m_totalRecordCount);
+	result["StartIndex"] = toJsonValue<qint32>(m_startIndex);
+
 	return result;
 }
-QList<ActivityLogEntry *> ActivityLogEntryQueryResult::items() const { return m_items; }
-void ActivityLogEntryQueryResult::setItems(QList<ActivityLogEntry *> newItems) {
-	m_items = newItems;
-	emit itemsChanged(newItems);
-}
 
+QList<QSharedPointer<ActivityLogEntry>> ActivityLogEntryQueryResult::items() const { return m_items; }
+
+void ActivityLogEntryQueryResult::setItems(QList<QSharedPointer<ActivityLogEntry>> newItems) {
+	m_items = newItems;
+}
 qint32 ActivityLogEntryQueryResult::totalRecordCount() const { return m_totalRecordCount; }
+
 void ActivityLogEntryQueryResult::setTotalRecordCount(qint32 newTotalRecordCount) {
 	m_totalRecordCount = newTotalRecordCount;
-	emit totalRecordCountChanged(newTotalRecordCount);
 }
-
 qint32 ActivityLogEntryQueryResult::startIndex() const { return m_startIndex; }
+
 void ActivityLogEntryQueryResult::setStartIndex(qint32 newStartIndex) {
 	m_startIndex = newStartIndex;
-	emit startIndexChanged(newStartIndex);
 }
 
 

core/src/DTO/addvirtualfolderdto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-AddVirtualFolderDto::AddVirtualFolderDto(QObject *parent) : QObject(parent) {}
+AddVirtualFolderDto::AddVirtualFolderDto(QObject *parent) {}
 
-AddVirtualFolderDto *AddVirtualFolderDto::fromJSON(QJsonObject source, QObject *parent) {
-	AddVirtualFolderDto *instance = new AddVirtualFolderDto(parent);
-	instance->updateFromJSON(source);
+AddVirtualFolderDto AddVirtualFolderDto::fromJson(QJsonObject source) {AddVirtualFolderDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AddVirtualFolderDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AddVirtualFolderDto::setFromJson(QJsonObject source) {
+	m_libraryOptions = fromJsonValue<QSharedPointer<LibraryOptions>>(source["LibraryOptions"]);
+
 }
-QJsonObject AddVirtualFolderDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AddVirtualFolderDto::toJson() {
 	QJsonObject result;
+	result["LibraryOptions"] = toJsonValue<QSharedPointer<LibraryOptions>>(m_libraryOptions);
+
 	return result;
 }
-LibraryOptions * AddVirtualFolderDto::libraryOptions() const { return m_libraryOptions; }
-void AddVirtualFolderDto::setLibraryOptions(LibraryOptions * newLibraryOptions) {
+
+QSharedPointer<LibraryOptions> AddVirtualFolderDto::libraryOptions() const { return m_libraryOptions; }
+
+void AddVirtualFolderDto::setLibraryOptions(QSharedPointer<LibraryOptions> newLibraryOptions) {
 	m_libraryOptions = newLibraryOptions;
-	emit libraryOptionsChanged(newLibraryOptions);
 }
 
 

core/src/DTO/albuminfo.cpp

@@ -32,98 +32,114 @@
 namespace Jellyfin {
 namespace DTO {
 
-AlbumInfo::AlbumInfo(QObject *parent) : QObject(parent) {}
+AlbumInfo::AlbumInfo(QObject *parent) {}
 
-AlbumInfo *AlbumInfo::fromJSON(QJsonObject source, QObject *parent) {
-	AlbumInfo *instance = new AlbumInfo(parent);
-	instance->updateFromJSON(source);
+AlbumInfo AlbumInfo::fromJson(QJsonObject source) {AlbumInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AlbumInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AlbumInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_metadataLanguage = fromJsonValue<QString>(source["MetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_providerIds = fromJsonValue<QJsonObject>(source["ProviderIds"]);
+	m_year = fromJsonValue<qint32>(source["Year"]);
+	m_indexNumber = fromJsonValue<qint32>(source["IndexNumber"]);
+	m_parentIndexNumber = fromJsonValue<qint32>(source["ParentIndexNumber"]);
+	m_premiereDate = fromJsonValue<QDateTime>(source["PremiereDate"]);
+	m_isAutomated = fromJsonValue<bool>(source["IsAutomated"]);
+	m_albumArtists = fromJsonValue<QStringList>(source["AlbumArtists"]);
+	m_artistProviderIds = fromJsonValue<QJsonObject>(source["ArtistProviderIds"]);
+	m_songInfos = fromJsonValue<QList<QSharedPointer<SongInfo>>>(source["SongInfos"]);
+
 }
-QJsonObject AlbumInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AlbumInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["MetadataLanguage"] = toJsonValue<QString>(m_metadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["ProviderIds"] = toJsonValue<QJsonObject>(m_providerIds);
+	result["Year"] = toJsonValue<qint32>(m_year);
+	result["IndexNumber"] = toJsonValue<qint32>(m_indexNumber);
+	result["ParentIndexNumber"] = toJsonValue<qint32>(m_parentIndexNumber);
+	result["PremiereDate"] = toJsonValue<QDateTime>(m_premiereDate);
+	result["IsAutomated"] = toJsonValue<bool>(m_isAutomated);
+	result["AlbumArtists"] = toJsonValue<QStringList>(m_albumArtists);
+	result["ArtistProviderIds"] = toJsonValue<QJsonObject>(m_artistProviderIds);
+	result["SongInfos"] = toJsonValue<QList<QSharedPointer<SongInfo>>>(m_songInfos);
+
 	return result;
 }
+
 QString AlbumInfo::name() const { return m_name; }
+
 void AlbumInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString AlbumInfo::path() const { return m_path; }
+
 void AlbumInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString AlbumInfo::metadataLanguage() const { return m_metadataLanguage; }
+
 void AlbumInfo::setMetadataLanguage(QString newMetadataLanguage) {
 	m_metadataLanguage = newMetadataLanguage;
-	emit metadataLanguageChanged(newMetadataLanguage);
 }
-
 QString AlbumInfo::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void AlbumInfo::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QJsonObject AlbumInfo::providerIds() const { return m_providerIds; }
+
 void AlbumInfo::setProviderIds(QJsonObject newProviderIds) {
 	m_providerIds = newProviderIds;
-	emit providerIdsChanged(newProviderIds);
 }
-
 qint32 AlbumInfo::year() const { return m_year; }
+
 void AlbumInfo::setYear(qint32 newYear) {
 	m_year = newYear;
-	emit yearChanged(newYear);
 }
-
 qint32 AlbumInfo::indexNumber() const { return m_indexNumber; }
+
 void AlbumInfo::setIndexNumber(qint32 newIndexNumber) {
 	m_indexNumber = newIndexNumber;
-	emit indexNumberChanged(newIndexNumber);
 }
-
 qint32 AlbumInfo::parentIndexNumber() const { return m_parentIndexNumber; }
+
 void AlbumInfo::setParentIndexNumber(qint32 newParentIndexNumber) {
 	m_parentIndexNumber = newParentIndexNumber;
-	emit parentIndexNumberChanged(newParentIndexNumber);
 }
-
 QDateTime AlbumInfo::premiereDate() const { return m_premiereDate; }
+
 void AlbumInfo::setPremiereDate(QDateTime newPremiereDate) {
 	m_premiereDate = newPremiereDate;
-	emit premiereDateChanged(newPremiereDate);
 }
-
 bool AlbumInfo::isAutomated() const { return m_isAutomated; }
+
 void AlbumInfo::setIsAutomated(bool newIsAutomated) {
 	m_isAutomated = newIsAutomated;
-	emit isAutomatedChanged(newIsAutomated);
 }
-
 QStringList AlbumInfo::albumArtists() const { return m_albumArtists; }
+
 void AlbumInfo::setAlbumArtists(QStringList newAlbumArtists) {
 	m_albumArtists = newAlbumArtists;
-	emit albumArtistsChanged(newAlbumArtists);
 }
-
 QJsonObject AlbumInfo::artistProviderIds() const { return m_artistProviderIds; }
+
 void AlbumInfo::setArtistProviderIds(QJsonObject newArtistProviderIds) {
 	m_artistProviderIds = newArtistProviderIds;
-	emit artistProviderIdsChanged(newArtistProviderIds);
 }
+QList<QSharedPointer<SongInfo>> AlbumInfo::songInfos() const { return m_songInfos; }
 
-QList<SongInfo *> AlbumInfo::songInfos() const { return m_songInfos; }
-void AlbumInfo::setSongInfos(QList<SongInfo *> newSongInfos) {
+void AlbumInfo::setSongInfos(QList<QSharedPointer<SongInfo>> newSongInfos) {
 	m_songInfos = newSongInfos;
-	emit songInfosChanged(newSongInfos);
 }
 
 

core/src/DTO/albuminforemotesearchquery.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-AlbumInfoRemoteSearchQuery::AlbumInfoRemoteSearchQuery(QObject *parent) : QObject(parent) {}
+AlbumInfoRemoteSearchQuery::AlbumInfoRemoteSearchQuery(QObject *parent) {}
 
-AlbumInfoRemoteSearchQuery *AlbumInfoRemoteSearchQuery::fromJSON(QJsonObject source, QObject *parent) {
-	AlbumInfoRemoteSearchQuery *instance = new AlbumInfoRemoteSearchQuery(parent);
-	instance->updateFromJSON(source);
+AlbumInfoRemoteSearchQuery AlbumInfoRemoteSearchQuery::fromJson(QJsonObject source) {AlbumInfoRemoteSearchQuery instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AlbumInfoRemoteSearchQuery::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AlbumInfoRemoteSearchQuery::setFromJson(QJsonObject source) {
+	m_searchInfo = fromJsonValue<QSharedPointer<AlbumInfo>>(source["SearchInfo"]);
+	m_itemId = fromJsonValue<QUuid>(source["ItemId"]);
+	m_searchProviderName = fromJsonValue<QString>(source["SearchProviderName"]);
+	m_includeDisabledProviders = fromJsonValue<bool>(source["IncludeDisabledProviders"]);
+
 }
-QJsonObject AlbumInfoRemoteSearchQuery::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AlbumInfoRemoteSearchQuery::toJson() {
 	QJsonObject result;
+	result["SearchInfo"] = toJsonValue<QSharedPointer<AlbumInfo>>(m_searchInfo);
+	result["ItemId"] = toJsonValue<QUuid>(m_itemId);
+	result["SearchProviderName"] = toJsonValue<QString>(m_searchProviderName);
+	result["IncludeDisabledProviders"] = toJsonValue<bool>(m_includeDisabledProviders);
+
 	return result;
 }
-AlbumInfo * AlbumInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
-void AlbumInfoRemoteSearchQuery::setSearchInfo(AlbumInfo * newSearchInfo) {
+
+QSharedPointer<AlbumInfo> AlbumInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
+
+void AlbumInfoRemoteSearchQuery::setSearchInfo(QSharedPointer<AlbumInfo> newSearchInfo) {
 	m_searchInfo = newSearchInfo;
-	emit searchInfoChanged(newSearchInfo);
 }
+QUuid AlbumInfoRemoteSearchQuery::itemId() const { return m_itemId; }
 
-QString AlbumInfoRemoteSearchQuery::itemId() const { return m_itemId; }
-void AlbumInfoRemoteSearchQuery::setItemId(QString newItemId) {
+void AlbumInfoRemoteSearchQuery::setItemId(QUuid newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QString AlbumInfoRemoteSearchQuery::searchProviderName() const { return m_searchProviderName; }
+
 void AlbumInfoRemoteSearchQuery::setSearchProviderName(QString newSearchProviderName) {
 	m_searchProviderName = newSearchProviderName;
-	emit searchProviderNameChanged(newSearchProviderName);
 }
-
 bool AlbumInfoRemoteSearchQuery::includeDisabledProviders() const { return m_includeDisabledProviders; }
+
 void AlbumInfoRemoteSearchQuery::setIncludeDisabledProviders(bool newIncludeDisabledProviders) {
 	m_includeDisabledProviders = newIncludeDisabledProviders;
-	emit includeDisabledProvidersChanged(newIncludeDisabledProviders);
 }
 
 

core/src/DTO/allthememediaresult.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-AllThemeMediaResult::AllThemeMediaResult(QObject *parent) : QObject(parent) {}
+AllThemeMediaResult::AllThemeMediaResult(QObject *parent) {}
 
-AllThemeMediaResult *AllThemeMediaResult::fromJSON(QJsonObject source, QObject *parent) {
-	AllThemeMediaResult *instance = new AllThemeMediaResult(parent);
-	instance->updateFromJSON(source);
+AllThemeMediaResult AllThemeMediaResult::fromJson(QJsonObject source) {AllThemeMediaResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AllThemeMediaResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AllThemeMediaResult::setFromJson(QJsonObject source) {
+	m_themeVideosResult = fromJsonValue<QSharedPointer<ThemeMediaResult>>(source["ThemeVideosResult"]);
+	m_themeSongsResult = fromJsonValue<QSharedPointer<ThemeMediaResult>>(source["ThemeSongsResult"]);
+	m_soundtrackSongsResult = fromJsonValue<QSharedPointer<ThemeMediaResult>>(source["SoundtrackSongsResult"]);
+
 }
-QJsonObject AllThemeMediaResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AllThemeMediaResult::toJson() {
 	QJsonObject result;
+	result["ThemeVideosResult"] = toJsonValue<QSharedPointer<ThemeMediaResult>>(m_themeVideosResult);
+	result["ThemeSongsResult"] = toJsonValue<QSharedPointer<ThemeMediaResult>>(m_themeSongsResult);
+	result["SoundtrackSongsResult"] = toJsonValue<QSharedPointer<ThemeMediaResult>>(m_soundtrackSongsResult);
+
 	return result;
 }
-ThemeMediaResult * AllThemeMediaResult::themeVideosResult() const { return m_themeVideosResult; }
-void AllThemeMediaResult::setThemeVideosResult(ThemeMediaResult * newThemeVideosResult) {
+
+QSharedPointer<ThemeMediaResult> AllThemeMediaResult::themeVideosResult() const { return m_themeVideosResult; }
+
+void AllThemeMediaResult::setThemeVideosResult(QSharedPointer<ThemeMediaResult> newThemeVideosResult) {
 	m_themeVideosResult = newThemeVideosResult;
-	emit themeVideosResultChanged(newThemeVideosResult);
 }
+QSharedPointer<ThemeMediaResult> AllThemeMediaResult::themeSongsResult() const { return m_themeSongsResult; }
 
-ThemeMediaResult * AllThemeMediaResult::themeSongsResult() const { return m_themeSongsResult; }
-void AllThemeMediaResult::setThemeSongsResult(ThemeMediaResult * newThemeSongsResult) {
+void AllThemeMediaResult::setThemeSongsResult(QSharedPointer<ThemeMediaResult> newThemeSongsResult) {
 	m_themeSongsResult = newThemeSongsResult;
-	emit themeSongsResultChanged(newThemeSongsResult);
 }
+QSharedPointer<ThemeMediaResult> AllThemeMediaResult::soundtrackSongsResult() const { return m_soundtrackSongsResult; }
 
-ThemeMediaResult * AllThemeMediaResult::soundtrackSongsResult() const { return m_soundtrackSongsResult; }
-void AllThemeMediaResult::setSoundtrackSongsResult(ThemeMediaResult * newSoundtrackSongsResult) {
+void AllThemeMediaResult::setSoundtrackSongsResult(QSharedPointer<ThemeMediaResult> newSoundtrackSongsResult) {
 	m_soundtrackSongsResult = newSoundtrackSongsResult;
-	emit soundtrackSongsResultChanged(newSoundtrackSongsResult);
 }
 
 

core/src/DTO/artistinfo.cpp

@@ -32,86 +32,100 @@
 namespace Jellyfin {
 namespace DTO {
 
-ArtistInfo::ArtistInfo(QObject *parent) : QObject(parent) {}
+ArtistInfo::ArtistInfo(QObject *parent) {}
 
-ArtistInfo *ArtistInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ArtistInfo *instance = new ArtistInfo(parent);
-	instance->updateFromJSON(source);
+ArtistInfo ArtistInfo::fromJson(QJsonObject source) {ArtistInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ArtistInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ArtistInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_metadataLanguage = fromJsonValue<QString>(source["MetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_providerIds = fromJsonValue<QJsonObject>(source["ProviderIds"]);
+	m_year = fromJsonValue<qint32>(source["Year"]);
+	m_indexNumber = fromJsonValue<qint32>(source["IndexNumber"]);
+	m_parentIndexNumber = fromJsonValue<qint32>(source["ParentIndexNumber"]);
+	m_premiereDate = fromJsonValue<QDateTime>(source["PremiereDate"]);
+	m_isAutomated = fromJsonValue<bool>(source["IsAutomated"]);
+	m_songInfos = fromJsonValue<QList<QSharedPointer<SongInfo>>>(source["SongInfos"]);
+
 }
-QJsonObject ArtistInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ArtistInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["MetadataLanguage"] = toJsonValue<QString>(m_metadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["ProviderIds"] = toJsonValue<QJsonObject>(m_providerIds);
+	result["Year"] = toJsonValue<qint32>(m_year);
+	result["IndexNumber"] = toJsonValue<qint32>(m_indexNumber);
+	result["ParentIndexNumber"] = toJsonValue<qint32>(m_parentIndexNumber);
+	result["PremiereDate"] = toJsonValue<QDateTime>(m_premiereDate);
+	result["IsAutomated"] = toJsonValue<bool>(m_isAutomated);
+	result["SongInfos"] = toJsonValue<QList<QSharedPointer<SongInfo>>>(m_songInfos);
+
 	return result;
 }
+
 QString ArtistInfo::name() const { return m_name; }
+
 void ArtistInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ArtistInfo::path() const { return m_path; }
+
 void ArtistInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString ArtistInfo::metadataLanguage() const { return m_metadataLanguage; }
+
 void ArtistInfo::setMetadataLanguage(QString newMetadataLanguage) {
 	m_metadataLanguage = newMetadataLanguage;
-	emit metadataLanguageChanged(newMetadataLanguage);
 }
-
 QString ArtistInfo::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void ArtistInfo::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QJsonObject ArtistInfo::providerIds() const { return m_providerIds; }
+
 void ArtistInfo::setProviderIds(QJsonObject newProviderIds) {
 	m_providerIds = newProviderIds;
-	emit providerIdsChanged(newProviderIds);
 }
-
 qint32 ArtistInfo::year() const { return m_year; }
+
 void ArtistInfo::setYear(qint32 newYear) {
 	m_year = newYear;
-	emit yearChanged(newYear);
 }
-
 qint32 ArtistInfo::indexNumber() const { return m_indexNumber; }
+
 void ArtistInfo::setIndexNumber(qint32 newIndexNumber) {
 	m_indexNumber = newIndexNumber;
-	emit indexNumberChanged(newIndexNumber);
 }
-
 qint32 ArtistInfo::parentIndexNumber() const { return m_parentIndexNumber; }
+
 void ArtistInfo::setParentIndexNumber(qint32 newParentIndexNumber) {
 	m_parentIndexNumber = newParentIndexNumber;
-	emit parentIndexNumberChanged(newParentIndexNumber);
 }
-
 QDateTime ArtistInfo::premiereDate() const { return m_premiereDate; }
+
 void ArtistInfo::setPremiereDate(QDateTime newPremiereDate) {
 	m_premiereDate = newPremiereDate;
-	emit premiereDateChanged(newPremiereDate);
 }
-
 bool ArtistInfo::isAutomated() const { return m_isAutomated; }
+
 void ArtistInfo::setIsAutomated(bool newIsAutomated) {
 	m_isAutomated = newIsAutomated;
-	emit isAutomatedChanged(newIsAutomated);
 }
+QList<QSharedPointer<SongInfo>> ArtistInfo::songInfos() const { return m_songInfos; }
 
-QList<SongInfo *> ArtistInfo::songInfos() const { return m_songInfos; }
-void ArtistInfo::setSongInfos(QList<SongInfo *> newSongInfos) {
+void ArtistInfo::setSongInfos(QList<QSharedPointer<SongInfo>> newSongInfos) {
 	m_songInfos = newSongInfos;
-	emit songInfosChanged(newSongInfos);
 }
 
 

core/src/DTO/artistinforemotesearchquery.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-ArtistInfoRemoteSearchQuery::ArtistInfoRemoteSearchQuery(QObject *parent) : QObject(parent) {}
+ArtistInfoRemoteSearchQuery::ArtistInfoRemoteSearchQuery(QObject *parent) {}
 
-ArtistInfoRemoteSearchQuery *ArtistInfoRemoteSearchQuery::fromJSON(QJsonObject source, QObject *parent) {
-	ArtistInfoRemoteSearchQuery *instance = new ArtistInfoRemoteSearchQuery(parent);
-	instance->updateFromJSON(source);
+ArtistInfoRemoteSearchQuery ArtistInfoRemoteSearchQuery::fromJson(QJsonObject source) {ArtistInfoRemoteSearchQuery instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ArtistInfoRemoteSearchQuery::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ArtistInfoRemoteSearchQuery::setFromJson(QJsonObject source) {
+	m_searchInfo = fromJsonValue<QSharedPointer<ArtistInfo>>(source["SearchInfo"]);
+	m_itemId = fromJsonValue<QUuid>(source["ItemId"]);
+	m_searchProviderName = fromJsonValue<QString>(source["SearchProviderName"]);
+	m_includeDisabledProviders = fromJsonValue<bool>(source["IncludeDisabledProviders"]);
+
 }
-QJsonObject ArtistInfoRemoteSearchQuery::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ArtistInfoRemoteSearchQuery::toJson() {
 	QJsonObject result;
+	result["SearchInfo"] = toJsonValue<QSharedPointer<ArtistInfo>>(m_searchInfo);
+	result["ItemId"] = toJsonValue<QUuid>(m_itemId);
+	result["SearchProviderName"] = toJsonValue<QString>(m_searchProviderName);
+	result["IncludeDisabledProviders"] = toJsonValue<bool>(m_includeDisabledProviders);
+
 	return result;
 }
-ArtistInfo * ArtistInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
-void ArtistInfoRemoteSearchQuery::setSearchInfo(ArtistInfo * newSearchInfo) {
+
+QSharedPointer<ArtistInfo> ArtistInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
+
+void ArtistInfoRemoteSearchQuery::setSearchInfo(QSharedPointer<ArtistInfo> newSearchInfo) {
 	m_searchInfo = newSearchInfo;
-	emit searchInfoChanged(newSearchInfo);
 }
+QUuid ArtistInfoRemoteSearchQuery::itemId() const { return m_itemId; }
 
-QString ArtistInfoRemoteSearchQuery::itemId() const { return m_itemId; }
-void ArtistInfoRemoteSearchQuery::setItemId(QString newItemId) {
+void ArtistInfoRemoteSearchQuery::setItemId(QUuid newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QString ArtistInfoRemoteSearchQuery::searchProviderName() const { return m_searchProviderName; }
+
 void ArtistInfoRemoteSearchQuery::setSearchProviderName(QString newSearchProviderName) {
 	m_searchProviderName = newSearchProviderName;
-	emit searchProviderNameChanged(newSearchProviderName);
 }
-
 bool ArtistInfoRemoteSearchQuery::includeDisabledProviders() const { return m_includeDisabledProviders; }
+
 void ArtistInfoRemoteSearchQuery::setIncludeDisabledProviders(bool newIncludeDisabledProviders) {
 	m_includeDisabledProviders = newIncludeDisabledProviders;
-	emit includeDisabledProvidersChanged(newIncludeDisabledProviders);
 }
 
 

core/src/DTO/authenticateuserbyname.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-AuthenticateUserByName::AuthenticateUserByName(QObject *parent) : QObject(parent) {}
+AuthenticateUserByName::AuthenticateUserByName(QObject *parent) {}
 
-AuthenticateUserByName *AuthenticateUserByName::fromJSON(QJsonObject source, QObject *parent) {
-	AuthenticateUserByName *instance = new AuthenticateUserByName(parent);
-	instance->updateFromJSON(source);
+AuthenticateUserByName AuthenticateUserByName::fromJson(QJsonObject source) {AuthenticateUserByName instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AuthenticateUserByName::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AuthenticateUserByName::setFromJson(QJsonObject source) {
+	m_username = fromJsonValue<QString>(source["Username"]);
+	m_pw = fromJsonValue<QString>(source["Pw"]);
+	m_password = fromJsonValue<QString>(source["Password"]);
+
 }
-QJsonObject AuthenticateUserByName::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AuthenticateUserByName::toJson() {
 	QJsonObject result;
+	result["Username"] = toJsonValue<QString>(m_username);
+	result["Pw"] = toJsonValue<QString>(m_pw);
+	result["Password"] = toJsonValue<QString>(m_password);
+
 	return result;
 }
+
 QString AuthenticateUserByName::username() const { return m_username; }
+
 void AuthenticateUserByName::setUsername(QString newUsername) {
 	m_username = newUsername;
-	emit usernameChanged(newUsername);
 }
-
 QString AuthenticateUserByName::pw() const { return m_pw; }
+
 void AuthenticateUserByName::setPw(QString newPw) {
 	m_pw = newPw;
-	emit pwChanged(newPw);
 }
-
 QString AuthenticateUserByName::password() const { return m_password; }
+
 void AuthenticateUserByName::setPassword(QString newPassword) {
 	m_password = newPassword;
-	emit passwordChanged(newPassword);
 }
 
 

core/src/DTO/authenticationinfo.cpp

@@ -32,92 +32,107 @@
 namespace Jellyfin {
 namespace DTO {
 
-AuthenticationInfo::AuthenticationInfo(QObject *parent) : QObject(parent) {}
+AuthenticationInfo::AuthenticationInfo(QObject *parent) {}
 
-AuthenticationInfo *AuthenticationInfo::fromJSON(QJsonObject source, QObject *parent) {
-	AuthenticationInfo *instance = new AuthenticationInfo(parent);
-	instance->updateFromJSON(source);
+AuthenticationInfo AuthenticationInfo::fromJson(QJsonObject source) {AuthenticationInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AuthenticationInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AuthenticationInfo::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<qint64>(source["Id"]);
+	m_accessToken = fromJsonValue<QString>(source["AccessToken"]);
+	m_deviceId = fromJsonValue<QString>(source["DeviceId"]);
+	m_appName = fromJsonValue<QString>(source["AppName"]);
+	m_appVersion = fromJsonValue<QString>(source["AppVersion"]);
+	m_deviceName = fromJsonValue<QString>(source["DeviceName"]);
+	m_userId = fromJsonValue<QUuid>(source["UserId"]);
+	m_isActive = fromJsonValue<bool>(source["IsActive"]);
+	m_dateCreated = fromJsonValue<QDateTime>(source["DateCreated"]);
+	m_dateRevoked = fromJsonValue<QDateTime>(source["DateRevoked"]);
+	m_dateLastActivity = fromJsonValue<QDateTime>(source["DateLastActivity"]);
+	m_userName = fromJsonValue<QString>(source["UserName"]);
+
 }
-QJsonObject AuthenticationInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AuthenticationInfo::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<qint64>(m_jellyfinId);
+	result["AccessToken"] = toJsonValue<QString>(m_accessToken);
+	result["DeviceId"] = toJsonValue<QString>(m_deviceId);
+	result["AppName"] = toJsonValue<QString>(m_appName);
+	result["AppVersion"] = toJsonValue<QString>(m_appVersion);
+	result["DeviceName"] = toJsonValue<QString>(m_deviceName);
+	result["UserId"] = toJsonValue<QUuid>(m_userId);
+	result["IsActive"] = toJsonValue<bool>(m_isActive);
+	result["DateCreated"] = toJsonValue<QDateTime>(m_dateCreated);
+	result["DateRevoked"] = toJsonValue<QDateTime>(m_dateRevoked);
+	result["DateLastActivity"] = toJsonValue<QDateTime>(m_dateLastActivity);
+	result["UserName"] = toJsonValue<QString>(m_userName);
+
 	return result;
 }
+
 qint64 AuthenticationInfo::jellyfinId() const { return m_jellyfinId; }
+
 void AuthenticationInfo::setJellyfinId(qint64 newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString AuthenticationInfo::accessToken() const { return m_accessToken; }
+
 void AuthenticationInfo::setAccessToken(QString newAccessToken) {
 	m_accessToken = newAccessToken;
-	emit accessTokenChanged(newAccessToken);
 }
-
 QString AuthenticationInfo::deviceId() const { return m_deviceId; }
+
 void AuthenticationInfo::setDeviceId(QString newDeviceId) {
 	m_deviceId = newDeviceId;
-	emit deviceIdChanged(newDeviceId);
 }
-
 QString AuthenticationInfo::appName() const { return m_appName; }
+
 void AuthenticationInfo::setAppName(QString newAppName) {
 	m_appName = newAppName;
-	emit appNameChanged(newAppName);
 }
-
 QString AuthenticationInfo::appVersion() const { return m_appVersion; }
+
 void AuthenticationInfo::setAppVersion(QString newAppVersion) {
 	m_appVersion = newAppVersion;
-	emit appVersionChanged(newAppVersion);
 }
-
 QString AuthenticationInfo::deviceName() const { return m_deviceName; }
+
 void AuthenticationInfo::setDeviceName(QString newDeviceName) {
 	m_deviceName = newDeviceName;
-	emit deviceNameChanged(newDeviceName);
 }
+QUuid AuthenticationInfo::userId() const { return m_userId; }
 
-QString AuthenticationInfo::userId() const { return m_userId; }
-void AuthenticationInfo::setUserId(QString newUserId) {
+void AuthenticationInfo::setUserId(QUuid newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 bool AuthenticationInfo::isActive() const { return m_isActive; }
+
 void AuthenticationInfo::setIsActive(bool newIsActive) {
 	m_isActive = newIsActive;
-	emit isActiveChanged(newIsActive);
 }
-
 QDateTime AuthenticationInfo::dateCreated() const { return m_dateCreated; }
+
 void AuthenticationInfo::setDateCreated(QDateTime newDateCreated) {
 	m_dateCreated = newDateCreated;
-	emit dateCreatedChanged(newDateCreated);
 }
-
 QDateTime AuthenticationInfo::dateRevoked() const { return m_dateRevoked; }
+
 void AuthenticationInfo::setDateRevoked(QDateTime newDateRevoked) {
 	m_dateRevoked = newDateRevoked;
-	emit dateRevokedChanged(newDateRevoked);
 }
-
 QDateTime AuthenticationInfo::dateLastActivity() const { return m_dateLastActivity; }
+
 void AuthenticationInfo::setDateLastActivity(QDateTime newDateLastActivity) {
 	m_dateLastActivity = newDateLastActivity;
-	emit dateLastActivityChanged(newDateLastActivity);
 }
-
 QString AuthenticationInfo::userName() const { return m_userName; }
+
 void AuthenticationInfo::setUserName(QString newUserName) {
 	m_userName = newUserName;
-	emit userNameChanged(newUserName);
 }
 
 

core/src/DTO/authenticationinfoqueryresult.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-AuthenticationInfoQueryResult::AuthenticationInfoQueryResult(QObject *parent) : QObject(parent) {}
+AuthenticationInfoQueryResult::AuthenticationInfoQueryResult(QObject *parent) {}
 
-AuthenticationInfoQueryResult *AuthenticationInfoQueryResult::fromJSON(QJsonObject source, QObject *parent) {
-	AuthenticationInfoQueryResult *instance = new AuthenticationInfoQueryResult(parent);
-	instance->updateFromJSON(source);
+AuthenticationInfoQueryResult AuthenticationInfoQueryResult::fromJson(QJsonObject source) {AuthenticationInfoQueryResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AuthenticationInfoQueryResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AuthenticationInfoQueryResult::setFromJson(QJsonObject source) {
+	m_items = fromJsonValue<QList<QSharedPointer<AuthenticationInfo>>>(source["Items"]);
+	m_totalRecordCount = fromJsonValue<qint32>(source["TotalRecordCount"]);
+	m_startIndex = fromJsonValue<qint32>(source["StartIndex"]);
+
 }
-QJsonObject AuthenticationInfoQueryResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AuthenticationInfoQueryResult::toJson() {
 	QJsonObject result;
+	result["Items"] = toJsonValue<QList<QSharedPointer<AuthenticationInfo>>>(m_items);
+	result["TotalRecordCount"] = toJsonValue<qint32>(m_totalRecordCount);
+	result["StartIndex"] = toJsonValue<qint32>(m_startIndex);
+
 	return result;
 }
-QList<AuthenticationInfo *> AuthenticationInfoQueryResult::items() const { return m_items; }
-void AuthenticationInfoQueryResult::setItems(QList<AuthenticationInfo *> newItems) {
-	m_items = newItems;
-	emit itemsChanged(newItems);
-}
 
+QList<QSharedPointer<AuthenticationInfo>> AuthenticationInfoQueryResult::items() const { return m_items; }
+
+void AuthenticationInfoQueryResult::setItems(QList<QSharedPointer<AuthenticationInfo>> newItems) {
+	m_items = newItems;
+}
 qint32 AuthenticationInfoQueryResult::totalRecordCount() const { return m_totalRecordCount; }
+
 void AuthenticationInfoQueryResult::setTotalRecordCount(qint32 newTotalRecordCount) {
 	m_totalRecordCount = newTotalRecordCount;
-	emit totalRecordCountChanged(newTotalRecordCount);
 }
-
 qint32 AuthenticationInfoQueryResult::startIndex() const { return m_startIndex; }
+
 void AuthenticationInfoQueryResult::setStartIndex(qint32 newStartIndex) {
 	m_startIndex = newStartIndex;
-	emit startIndexChanged(newStartIndex);
 }
 
 

core/src/DTO/authenticationresult.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-AuthenticationResult::AuthenticationResult(QObject *parent) : QObject(parent) {}
+AuthenticationResult::AuthenticationResult(QObject *parent) {}
 
-AuthenticationResult *AuthenticationResult::fromJSON(QJsonObject source, QObject *parent) {
-	AuthenticationResult *instance = new AuthenticationResult(parent);
-	instance->updateFromJSON(source);
+AuthenticationResult AuthenticationResult::fromJson(QJsonObject source) {AuthenticationResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void AuthenticationResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void AuthenticationResult::setFromJson(QJsonObject source) {
+	m_user = fromJsonValue<QSharedPointer<UserDto>>(source["User"]);
+	m_sessionInfo = fromJsonValue<QSharedPointer<SessionInfo>>(source["SessionInfo"]);
+	m_accessToken = fromJsonValue<QString>(source["AccessToken"]);
+	m_serverId = fromJsonValue<QString>(source["ServerId"]);
+
 }
-QJsonObject AuthenticationResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject AuthenticationResult::toJson() {
 	QJsonObject result;
+	result["User"] = toJsonValue<QSharedPointer<UserDto>>(m_user);
+	result["SessionInfo"] = toJsonValue<QSharedPointer<SessionInfo>>(m_sessionInfo);
+	result["AccessToken"] = toJsonValue<QString>(m_accessToken);
+	result["ServerId"] = toJsonValue<QString>(m_serverId);
+
 	return result;
 }
-UserDto * AuthenticationResult::user() const { return m_user; }
-void AuthenticationResult::setUser(UserDto * newUser) {
+
+QSharedPointer<UserDto> AuthenticationResult::user() const { return m_user; }
+
+void AuthenticationResult::setUser(QSharedPointer<UserDto> newUser) {
 	m_user = newUser;
-	emit userChanged(newUser);
 }
+QSharedPointer<SessionInfo> AuthenticationResult::sessionInfo() const { return m_sessionInfo; }
 
-SessionInfo * AuthenticationResult::sessionInfo() const { return m_sessionInfo; }
-void AuthenticationResult::setSessionInfo(SessionInfo * newSessionInfo) {
+void AuthenticationResult::setSessionInfo(QSharedPointer<SessionInfo> newSessionInfo) {
 	m_sessionInfo = newSessionInfo;
-	emit sessionInfoChanged(newSessionInfo);
 }
-
 QString AuthenticationResult::accessToken() const { return m_accessToken; }
+
 void AuthenticationResult::setAccessToken(QString newAccessToken) {
 	m_accessToken = newAccessToken;
-	emit accessTokenChanged(newAccessToken);
 }
-
 QString AuthenticationResult::serverId() const { return m_serverId; }
+
 void AuthenticationResult::setServerId(QString newServerId) {
 	m_serverId = newServerId;
-	emit serverIdChanged(newServerId);
 }
 
 

core/src/DTO/baseitem.cpp

@@ -32,86 +32,100 @@
 namespace Jellyfin {
 namespace DTO {
 
-BaseItem::BaseItem(QObject *parent) : QObject(parent) {}
+BaseItem::BaseItem(QObject *parent) {}
 
-BaseItem *BaseItem::fromJSON(QJsonObject source, QObject *parent) {
-	BaseItem *instance = new BaseItem(parent);
-	instance->updateFromJSON(source);
+BaseItem BaseItem::fromJson(QJsonObject source) {BaseItem instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BaseItem::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BaseItem::setFromJson(QJsonObject source) {
+	m_size = fromJsonValue<qint64>(source["Size"]);
+	m_container = fromJsonValue<QString>(source["Container"]);
+	m_dateLastSaved = fromJsonValue<QDateTime>(source["DateLastSaved"]);
+	m_remoteTrailers = fromJsonValue<QList<QSharedPointer<MediaUrl>>>(source["RemoteTrailers"]);
+	m_isHD = fromJsonValue<bool>(source["IsHD"]);
+	m_isShortcut = fromJsonValue<bool>(source["IsShortcut"]);
+	m_shortcutPath = fromJsonValue<QString>(source["ShortcutPath"]);
+	m_width = fromJsonValue<qint32>(source["Width"]);
+	m_height = fromJsonValue<qint32>(source["Height"]);
+	m_extraIds = fromJsonValue<QList<QUuid>>(source["ExtraIds"]);
+	m_supportsExternalTransfer = fromJsonValue<bool>(source["SupportsExternalTransfer"]);
+
 }
-QJsonObject BaseItem::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BaseItem::toJson() {
 	QJsonObject result;
+	result["Size"] = toJsonValue<qint64>(m_size);
+	result["Container"] = toJsonValue<QString>(m_container);
+	result["DateLastSaved"] = toJsonValue<QDateTime>(m_dateLastSaved);
+	result["RemoteTrailers"] = toJsonValue<QList<QSharedPointer<MediaUrl>>>(m_remoteTrailers);
+	result["IsHD"] = toJsonValue<bool>(m_isHD);
+	result["IsShortcut"] = toJsonValue<bool>(m_isShortcut);
+	result["ShortcutPath"] = toJsonValue<QString>(m_shortcutPath);
+	result["Width"] = toJsonValue<qint32>(m_width);
+	result["Height"] = toJsonValue<qint32>(m_height);
+	result["ExtraIds"] = toJsonValue<QList<QUuid>>(m_extraIds);
+	result["SupportsExternalTransfer"] = toJsonValue<bool>(m_supportsExternalTransfer);
+
 	return result;
 }
+
 qint64 BaseItem::size() const { return m_size; }
+
 void BaseItem::setSize(qint64 newSize) {
 	m_size = newSize;
-	emit sizeChanged(newSize);
 }
-
 QString BaseItem::container() const { return m_container; }
+
 void BaseItem::setContainer(QString newContainer) {
 	m_container = newContainer;
-	emit containerChanged(newContainer);
 }
-
 QDateTime BaseItem::dateLastSaved() const { return m_dateLastSaved; }
+
 void BaseItem::setDateLastSaved(QDateTime newDateLastSaved) {
 	m_dateLastSaved = newDateLastSaved;
-	emit dateLastSavedChanged(newDateLastSaved);
 }
+QList<QSharedPointer<MediaUrl>> BaseItem::remoteTrailers() const { return m_remoteTrailers; }
 
-QList<MediaUrl *> BaseItem::remoteTrailers() const { return m_remoteTrailers; }
-void BaseItem::setRemoteTrailers(QList<MediaUrl *> newRemoteTrailers) {
+void BaseItem::setRemoteTrailers(QList<QSharedPointer<MediaUrl>> newRemoteTrailers) {
 	m_remoteTrailers = newRemoteTrailers;
-	emit remoteTrailersChanged(newRemoteTrailers);
 }
-
 bool BaseItem::isHD() const { return m_isHD; }
+
 void BaseItem::setIsHD(bool newIsHD) {
 	m_isHD = newIsHD;
-	emit isHDChanged(newIsHD);
 }
-
 bool BaseItem::isShortcut() const { return m_isShortcut; }
+
 void BaseItem::setIsShortcut(bool newIsShortcut) {
 	m_isShortcut = newIsShortcut;
-	emit isShortcutChanged(newIsShortcut);
 }
-
 QString BaseItem::shortcutPath() const { return m_shortcutPath; }
+
 void BaseItem::setShortcutPath(QString newShortcutPath) {
 	m_shortcutPath = newShortcutPath;
-	emit shortcutPathChanged(newShortcutPath);
 }
-
 qint32 BaseItem::width() const { return m_width; }
+
 void BaseItem::setWidth(qint32 newWidth) {
 	m_width = newWidth;
-	emit widthChanged(newWidth);
 }
-
 qint32 BaseItem::height() const { return m_height; }
+
 void BaseItem::setHeight(qint32 newHeight) {
 	m_height = newHeight;
-	emit heightChanged(newHeight);
 }
+QList<QUuid> BaseItem::extraIds() const { return m_extraIds; }
 
-QStringList BaseItem::extraIds() const { return m_extraIds; }
-void BaseItem::setExtraIds(QStringList newExtraIds) {
+void BaseItem::setExtraIds(QList<QUuid> newExtraIds) {
 	m_extraIds = newExtraIds;
-	emit extraIdsChanged(newExtraIds);
 }
-
 bool BaseItem::supportsExternalTransfer() const { return m_supportsExternalTransfer; }
+
 void BaseItem::setSupportsExternalTransfer(bool newSupportsExternalTransfer) {
 	m_supportsExternalTransfer = newSupportsExternalTransfer;
-	emit supportsExternalTransferChanged(newSupportsExternalTransfer);
 }
 
 

core/src/DTO/baseitemdtoqueryresult.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-BaseItemDtoQueryResult::BaseItemDtoQueryResult(QObject *parent) : QObject(parent) {}
+BaseItemDtoQueryResult::BaseItemDtoQueryResult(QObject *parent) {}
 
-BaseItemDtoQueryResult *BaseItemDtoQueryResult::fromJSON(QJsonObject source, QObject *parent) {
-	BaseItemDtoQueryResult *instance = new BaseItemDtoQueryResult(parent);
-	instance->updateFromJSON(source);
+BaseItemDtoQueryResult BaseItemDtoQueryResult::fromJson(QJsonObject source) {BaseItemDtoQueryResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BaseItemDtoQueryResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BaseItemDtoQueryResult::setFromJson(QJsonObject source) {
+	m_items = fromJsonValue<QList<QSharedPointer<BaseItemDto>>>(source["Items"]);
+	m_totalRecordCount = fromJsonValue<qint32>(source["TotalRecordCount"]);
+	m_startIndex = fromJsonValue<qint32>(source["StartIndex"]);
+
 }
-QJsonObject BaseItemDtoQueryResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BaseItemDtoQueryResult::toJson() {
 	QJsonObject result;
+	result["Items"] = toJsonValue<QList<QSharedPointer<BaseItemDto>>>(m_items);
+	result["TotalRecordCount"] = toJsonValue<qint32>(m_totalRecordCount);
+	result["StartIndex"] = toJsonValue<qint32>(m_startIndex);
+
 	return result;
 }
-QList<BaseItemDto *> BaseItemDtoQueryResult::items() const { return m_items; }
-void BaseItemDtoQueryResult::setItems(QList<BaseItemDto *> newItems) {
-	m_items = newItems;
-	emit itemsChanged(newItems);
-}
 
+QList<QSharedPointer<BaseItemDto>> BaseItemDtoQueryResult::items() const { return m_items; }
+
+void BaseItemDtoQueryResult::setItems(QList<QSharedPointer<BaseItemDto>> newItems) {
+	m_items = newItems;
+}
 qint32 BaseItemDtoQueryResult::totalRecordCount() const { return m_totalRecordCount; }
+
 void BaseItemDtoQueryResult::setTotalRecordCount(qint32 newTotalRecordCount) {
 	m_totalRecordCount = newTotalRecordCount;
-	emit totalRecordCountChanged(newTotalRecordCount);
 }
-
 qint32 BaseItemDtoQueryResult::startIndex() const { return m_startIndex; }
+
 void BaseItemDtoQueryResult::setStartIndex(qint32 newStartIndex) {
 	m_startIndex = newStartIndex;
-	emit startIndexChanged(newStartIndex);
 }
 
 

core/src/DTO/baseitemperson.cpp

@@ -32,56 +32,65 @@
 namespace Jellyfin {
 namespace DTO {
 
-BaseItemPerson::BaseItemPerson(QObject *parent) : QObject(parent) {}
+BaseItemPerson::BaseItemPerson(QObject *parent) {}
 
-BaseItemPerson *BaseItemPerson::fromJSON(QJsonObject source, QObject *parent) {
-	BaseItemPerson *instance = new BaseItemPerson(parent);
-	instance->updateFromJSON(source);
+BaseItemPerson BaseItemPerson::fromJson(QJsonObject source) {BaseItemPerson instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BaseItemPerson::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BaseItemPerson::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_role = fromJsonValue<QString>(source["Role"]);
+	m_type = fromJsonValue<QString>(source["Type"]);
+	m_primaryImageTag = fromJsonValue<QString>(source["PrimaryImageTag"]);
+	m_imageBlurHashes = fromJsonValue<QJsonObject>(source["ImageBlurHashes"]);
+
 }
-QJsonObject BaseItemPerson::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BaseItemPerson::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["Role"] = toJsonValue<QString>(m_role);
+	result["Type"] = toJsonValue<QString>(m_type);
+	result["PrimaryImageTag"] = toJsonValue<QString>(m_primaryImageTag);
+	result["ImageBlurHashes"] = toJsonValue<QJsonObject>(m_imageBlurHashes);
+
 	return result;
 }
+
 QString BaseItemPerson::name() const { return m_name; }
+
 void BaseItemPerson::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString BaseItemPerson::jellyfinId() const { return m_jellyfinId; }
+
 void BaseItemPerson::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString BaseItemPerson::role() const { return m_role; }
+
 void BaseItemPerson::setRole(QString newRole) {
 	m_role = newRole;
-	emit roleChanged(newRole);
 }
-
 QString BaseItemPerson::type() const { return m_type; }
+
 void BaseItemPerson::setType(QString newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 QString BaseItemPerson::primaryImageTag() const { return m_primaryImageTag; }
+
 void BaseItemPerson::setPrimaryImageTag(QString newPrimaryImageTag) {
 	m_primaryImageTag = newPrimaryImageTag;
-	emit primaryImageTagChanged(newPrimaryImageTag);
 }
-
 QJsonObject BaseItemPerson::imageBlurHashes() const { return m_imageBlurHashes; }
+
 void BaseItemPerson::setImageBlurHashes(QJsonObject newImageBlurHashes) {
 	m_imageBlurHashes = newImageBlurHashes;
-	emit imageBlurHashesChanged(newImageBlurHashes);
 }
 
 

core/src/DTO/bookinfo.cpp

@@ -32,86 +32,100 @@
 namespace Jellyfin {
 namespace DTO {
 
-BookInfo::BookInfo(QObject *parent) : QObject(parent) {}
+BookInfo::BookInfo(QObject *parent) {}
 
-BookInfo *BookInfo::fromJSON(QJsonObject source, QObject *parent) {
-	BookInfo *instance = new BookInfo(parent);
-	instance->updateFromJSON(source);
+BookInfo BookInfo::fromJson(QJsonObject source) {BookInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BookInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BookInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_metadataLanguage = fromJsonValue<QString>(source["MetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_providerIds = fromJsonValue<QJsonObject>(source["ProviderIds"]);
+	m_year = fromJsonValue<qint32>(source["Year"]);
+	m_indexNumber = fromJsonValue<qint32>(source["IndexNumber"]);
+	m_parentIndexNumber = fromJsonValue<qint32>(source["ParentIndexNumber"]);
+	m_premiereDate = fromJsonValue<QDateTime>(source["PremiereDate"]);
+	m_isAutomated = fromJsonValue<bool>(source["IsAutomated"]);
+	m_seriesName = fromJsonValue<QString>(source["SeriesName"]);
+
 }
-QJsonObject BookInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BookInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["MetadataLanguage"] = toJsonValue<QString>(m_metadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["ProviderIds"] = toJsonValue<QJsonObject>(m_providerIds);
+	result["Year"] = toJsonValue<qint32>(m_year);
+	result["IndexNumber"] = toJsonValue<qint32>(m_indexNumber);
+	result["ParentIndexNumber"] = toJsonValue<qint32>(m_parentIndexNumber);
+	result["PremiereDate"] = toJsonValue<QDateTime>(m_premiereDate);
+	result["IsAutomated"] = toJsonValue<bool>(m_isAutomated);
+	result["SeriesName"] = toJsonValue<QString>(m_seriesName);
+
 	return result;
 }
+
 QString BookInfo::name() const { return m_name; }
+
 void BookInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString BookInfo::path() const { return m_path; }
+
 void BookInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString BookInfo::metadataLanguage() const { return m_metadataLanguage; }
+
 void BookInfo::setMetadataLanguage(QString newMetadataLanguage) {
 	m_metadataLanguage = newMetadataLanguage;
-	emit metadataLanguageChanged(newMetadataLanguage);
 }
-
 QString BookInfo::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void BookInfo::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QJsonObject BookInfo::providerIds() const { return m_providerIds; }
+
 void BookInfo::setProviderIds(QJsonObject newProviderIds) {
 	m_providerIds = newProviderIds;
-	emit providerIdsChanged(newProviderIds);
 }
-
 qint32 BookInfo::year() const { return m_year; }
+
 void BookInfo::setYear(qint32 newYear) {
 	m_year = newYear;
-	emit yearChanged(newYear);
 }
-
 qint32 BookInfo::indexNumber() const { return m_indexNumber; }
+
 void BookInfo::setIndexNumber(qint32 newIndexNumber) {
 	m_indexNumber = newIndexNumber;
-	emit indexNumberChanged(newIndexNumber);
 }
-
 qint32 BookInfo::parentIndexNumber() const { return m_parentIndexNumber; }
+
 void BookInfo::setParentIndexNumber(qint32 newParentIndexNumber) {
 	m_parentIndexNumber = newParentIndexNumber;
-	emit parentIndexNumberChanged(newParentIndexNumber);
 }
-
 QDateTime BookInfo::premiereDate() const { return m_premiereDate; }
+
 void BookInfo::setPremiereDate(QDateTime newPremiereDate) {
 	m_premiereDate = newPremiereDate;
-	emit premiereDateChanged(newPremiereDate);
 }
-
 bool BookInfo::isAutomated() const { return m_isAutomated; }
+
 void BookInfo::setIsAutomated(bool newIsAutomated) {
 	m_isAutomated = newIsAutomated;
-	emit isAutomatedChanged(newIsAutomated);
 }
-
 QString BookInfo::seriesName() const { return m_seriesName; }
+
 void BookInfo::setSeriesName(QString newSeriesName) {
 	m_seriesName = newSeriesName;
-	emit seriesNameChanged(newSeriesName);
 }
 
 

core/src/DTO/bookinforemotesearchquery.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-BookInfoRemoteSearchQuery::BookInfoRemoteSearchQuery(QObject *parent) : QObject(parent) {}
+BookInfoRemoteSearchQuery::BookInfoRemoteSearchQuery(QObject *parent) {}
 
-BookInfoRemoteSearchQuery *BookInfoRemoteSearchQuery::fromJSON(QJsonObject source, QObject *parent) {
-	BookInfoRemoteSearchQuery *instance = new BookInfoRemoteSearchQuery(parent);
-	instance->updateFromJSON(source);
+BookInfoRemoteSearchQuery BookInfoRemoteSearchQuery::fromJson(QJsonObject source) {BookInfoRemoteSearchQuery instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BookInfoRemoteSearchQuery::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BookInfoRemoteSearchQuery::setFromJson(QJsonObject source) {
+	m_searchInfo = fromJsonValue<QSharedPointer<BookInfo>>(source["SearchInfo"]);
+	m_itemId = fromJsonValue<QUuid>(source["ItemId"]);
+	m_searchProviderName = fromJsonValue<QString>(source["SearchProviderName"]);
+	m_includeDisabledProviders = fromJsonValue<bool>(source["IncludeDisabledProviders"]);
+
 }
-QJsonObject BookInfoRemoteSearchQuery::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BookInfoRemoteSearchQuery::toJson() {
 	QJsonObject result;
+	result["SearchInfo"] = toJsonValue<QSharedPointer<BookInfo>>(m_searchInfo);
+	result["ItemId"] = toJsonValue<QUuid>(m_itemId);
+	result["SearchProviderName"] = toJsonValue<QString>(m_searchProviderName);
+	result["IncludeDisabledProviders"] = toJsonValue<bool>(m_includeDisabledProviders);
+
 	return result;
 }
-BookInfo * BookInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
-void BookInfoRemoteSearchQuery::setSearchInfo(BookInfo * newSearchInfo) {
+
+QSharedPointer<BookInfo> BookInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
+
+void BookInfoRemoteSearchQuery::setSearchInfo(QSharedPointer<BookInfo> newSearchInfo) {
 	m_searchInfo = newSearchInfo;
-	emit searchInfoChanged(newSearchInfo);
 }
+QUuid BookInfoRemoteSearchQuery::itemId() const { return m_itemId; }
 
-QString BookInfoRemoteSearchQuery::itemId() const { return m_itemId; }
-void BookInfoRemoteSearchQuery::setItemId(QString newItemId) {
+void BookInfoRemoteSearchQuery::setItemId(QUuid newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QString BookInfoRemoteSearchQuery::searchProviderName() const { return m_searchProviderName; }
+
 void BookInfoRemoteSearchQuery::setSearchProviderName(QString newSearchProviderName) {
 	m_searchProviderName = newSearchProviderName;
-	emit searchProviderNameChanged(newSearchProviderName);
 }
-
 bool BookInfoRemoteSearchQuery::includeDisabledProviders() const { return m_includeDisabledProviders; }
+
 void BookInfoRemoteSearchQuery::setIncludeDisabledProviders(bool newIncludeDisabledProviders) {
 	m_includeDisabledProviders = newIncludeDisabledProviders;
-	emit includeDisabledProvidersChanged(newIncludeDisabledProviders);
 }
 
 

core/src/DTO/boxsetinfo.cpp

@@ -32,80 +32,93 @@
 namespace Jellyfin {
 namespace DTO {
 
-BoxSetInfo::BoxSetInfo(QObject *parent) : QObject(parent) {}
+BoxSetInfo::BoxSetInfo(QObject *parent) {}
 
-BoxSetInfo *BoxSetInfo::fromJSON(QJsonObject source, QObject *parent) {
-	BoxSetInfo *instance = new BoxSetInfo(parent);
-	instance->updateFromJSON(source);
+BoxSetInfo BoxSetInfo::fromJson(QJsonObject source) {BoxSetInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BoxSetInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BoxSetInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_metadataLanguage = fromJsonValue<QString>(source["MetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_providerIds = fromJsonValue<QJsonObject>(source["ProviderIds"]);
+	m_year = fromJsonValue<qint32>(source["Year"]);
+	m_indexNumber = fromJsonValue<qint32>(source["IndexNumber"]);
+	m_parentIndexNumber = fromJsonValue<qint32>(source["ParentIndexNumber"]);
+	m_premiereDate = fromJsonValue<QDateTime>(source["PremiereDate"]);
+	m_isAutomated = fromJsonValue<bool>(source["IsAutomated"]);
+
 }
-QJsonObject BoxSetInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BoxSetInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["MetadataLanguage"] = toJsonValue<QString>(m_metadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["ProviderIds"] = toJsonValue<QJsonObject>(m_providerIds);
+	result["Year"] = toJsonValue<qint32>(m_year);
+	result["IndexNumber"] = toJsonValue<qint32>(m_indexNumber);
+	result["ParentIndexNumber"] = toJsonValue<qint32>(m_parentIndexNumber);
+	result["PremiereDate"] = toJsonValue<QDateTime>(m_premiereDate);
+	result["IsAutomated"] = toJsonValue<bool>(m_isAutomated);
+
 	return result;
 }
+
 QString BoxSetInfo::name() const { return m_name; }
+
 void BoxSetInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString BoxSetInfo::path() const { return m_path; }
+
 void BoxSetInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString BoxSetInfo::metadataLanguage() const { return m_metadataLanguage; }
+
 void BoxSetInfo::setMetadataLanguage(QString newMetadataLanguage) {
 	m_metadataLanguage = newMetadataLanguage;
-	emit metadataLanguageChanged(newMetadataLanguage);
 }
-
 QString BoxSetInfo::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void BoxSetInfo::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QJsonObject BoxSetInfo::providerIds() const { return m_providerIds; }
+
 void BoxSetInfo::setProviderIds(QJsonObject newProviderIds) {
 	m_providerIds = newProviderIds;
-	emit providerIdsChanged(newProviderIds);
 }
-
 qint32 BoxSetInfo::year() const { return m_year; }
+
 void BoxSetInfo::setYear(qint32 newYear) {
 	m_year = newYear;
-	emit yearChanged(newYear);
 }
-
 qint32 BoxSetInfo::indexNumber() const { return m_indexNumber; }
+
 void BoxSetInfo::setIndexNumber(qint32 newIndexNumber) {
 	m_indexNumber = newIndexNumber;
-	emit indexNumberChanged(newIndexNumber);
 }
-
 qint32 BoxSetInfo::parentIndexNumber() const { return m_parentIndexNumber; }
+
 void BoxSetInfo::setParentIndexNumber(qint32 newParentIndexNumber) {
 	m_parentIndexNumber = newParentIndexNumber;
-	emit parentIndexNumberChanged(newParentIndexNumber);
 }
-
 QDateTime BoxSetInfo::premiereDate() const { return m_premiereDate; }
+
 void BoxSetInfo::setPremiereDate(QDateTime newPremiereDate) {
 	m_premiereDate = newPremiereDate;
-	emit premiereDateChanged(newPremiereDate);
 }
-
 bool BoxSetInfo::isAutomated() const { return m_isAutomated; }
+
 void BoxSetInfo::setIsAutomated(bool newIsAutomated) {
 	m_isAutomated = newIsAutomated;
-	emit isAutomatedChanged(newIsAutomated);
 }
 
 

core/src/DTO/boxsetinforemotesearchquery.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-BoxSetInfoRemoteSearchQuery::BoxSetInfoRemoteSearchQuery(QObject *parent) : QObject(parent) {}
+BoxSetInfoRemoteSearchQuery::BoxSetInfoRemoteSearchQuery(QObject *parent) {}
 
-BoxSetInfoRemoteSearchQuery *BoxSetInfoRemoteSearchQuery::fromJSON(QJsonObject source, QObject *parent) {
-	BoxSetInfoRemoteSearchQuery *instance = new BoxSetInfoRemoteSearchQuery(parent);
-	instance->updateFromJSON(source);
+BoxSetInfoRemoteSearchQuery BoxSetInfoRemoteSearchQuery::fromJson(QJsonObject source) {BoxSetInfoRemoteSearchQuery instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BoxSetInfoRemoteSearchQuery::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BoxSetInfoRemoteSearchQuery::setFromJson(QJsonObject source) {
+	m_searchInfo = fromJsonValue<QSharedPointer<BoxSetInfo>>(source["SearchInfo"]);
+	m_itemId = fromJsonValue<QUuid>(source["ItemId"]);
+	m_searchProviderName = fromJsonValue<QString>(source["SearchProviderName"]);
+	m_includeDisabledProviders = fromJsonValue<bool>(source["IncludeDisabledProviders"]);
+
 }
-QJsonObject BoxSetInfoRemoteSearchQuery::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BoxSetInfoRemoteSearchQuery::toJson() {
 	QJsonObject result;
+	result["SearchInfo"] = toJsonValue<QSharedPointer<BoxSetInfo>>(m_searchInfo);
+	result["ItemId"] = toJsonValue<QUuid>(m_itemId);
+	result["SearchProviderName"] = toJsonValue<QString>(m_searchProviderName);
+	result["IncludeDisabledProviders"] = toJsonValue<bool>(m_includeDisabledProviders);
+
 	return result;
 }
-BoxSetInfo * BoxSetInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
-void BoxSetInfoRemoteSearchQuery::setSearchInfo(BoxSetInfo * newSearchInfo) {
+
+QSharedPointer<BoxSetInfo> BoxSetInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
+
+void BoxSetInfoRemoteSearchQuery::setSearchInfo(QSharedPointer<BoxSetInfo> newSearchInfo) {
 	m_searchInfo = newSearchInfo;
-	emit searchInfoChanged(newSearchInfo);
 }
+QUuid BoxSetInfoRemoteSearchQuery::itemId() const { return m_itemId; }
 
-QString BoxSetInfoRemoteSearchQuery::itemId() const { return m_itemId; }
-void BoxSetInfoRemoteSearchQuery::setItemId(QString newItemId) {
+void BoxSetInfoRemoteSearchQuery::setItemId(QUuid newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QString BoxSetInfoRemoteSearchQuery::searchProviderName() const { return m_searchProviderName; }
+
 void BoxSetInfoRemoteSearchQuery::setSearchProviderName(QString newSearchProviderName) {
 	m_searchProviderName = newSearchProviderName;
-	emit searchProviderNameChanged(newSearchProviderName);
 }
-
 bool BoxSetInfoRemoteSearchQuery::includeDisabledProviders() const { return m_includeDisabledProviders; }
+
 void BoxSetInfoRemoteSearchQuery::setIncludeDisabledProviders(bool newIncludeDisabledProviders) {
 	m_includeDisabledProviders = newIncludeDisabledProviders;
-	emit includeDisabledProvidersChanged(newIncludeDisabledProviders);
 }
 
 

core/src/DTO/brandingoptions.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-BrandingOptions::BrandingOptions(QObject *parent) : QObject(parent) {}
+BrandingOptions::BrandingOptions(QObject *parent) {}
 
-BrandingOptions *BrandingOptions::fromJSON(QJsonObject source, QObject *parent) {
-	BrandingOptions *instance = new BrandingOptions(parent);
-	instance->updateFromJSON(source);
+BrandingOptions BrandingOptions::fromJson(QJsonObject source) {BrandingOptions instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BrandingOptions::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BrandingOptions::setFromJson(QJsonObject source) {
+	m_loginDisclaimer = fromJsonValue<QString>(source["LoginDisclaimer"]);
+	m_customCss = fromJsonValue<QString>(source["CustomCss"]);
+
 }
-QJsonObject BrandingOptions::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BrandingOptions::toJson() {
 	QJsonObject result;
+	result["LoginDisclaimer"] = toJsonValue<QString>(m_loginDisclaimer);
+	result["CustomCss"] = toJsonValue<QString>(m_customCss);
+
 	return result;
 }
+
 QString BrandingOptions::loginDisclaimer() const { return m_loginDisclaimer; }
+
 void BrandingOptions::setLoginDisclaimer(QString newLoginDisclaimer) {
 	m_loginDisclaimer = newLoginDisclaimer;
-	emit loginDisclaimerChanged(newLoginDisclaimer);
 }
-
 QString BrandingOptions::customCss() const { return m_customCss; }
+
 void BrandingOptions::setCustomCss(QString newCustomCss) {
 	m_customCss = newCustomCss;
-	emit customCssChanged(newCustomCss);
 }
 
 

core/src/DTO/bufferrequestdto.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-BufferRequestDto::BufferRequestDto(QObject *parent) : QObject(parent) {}
+BufferRequestDto::BufferRequestDto(QObject *parent) {}
 
-BufferRequestDto *BufferRequestDto::fromJSON(QJsonObject source, QObject *parent) {
-	BufferRequestDto *instance = new BufferRequestDto(parent);
-	instance->updateFromJSON(source);
+BufferRequestDto BufferRequestDto::fromJson(QJsonObject source) {BufferRequestDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void BufferRequestDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void BufferRequestDto::setFromJson(QJsonObject source) {
+	m_when = fromJsonValue<QDateTime>(source["When"]);
+	m_positionTicks = fromJsonValue<qint64>(source["PositionTicks"]);
+	m_isPlaying = fromJsonValue<bool>(source["IsPlaying"]);
+	m_playlistItemId = fromJsonValue<QUuid>(source["PlaylistItemId"]);
+
 }
-QJsonObject BufferRequestDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject BufferRequestDto::toJson() {
 	QJsonObject result;
+	result["When"] = toJsonValue<QDateTime>(m_when);
+	result["PositionTicks"] = toJsonValue<qint64>(m_positionTicks);
+	result["IsPlaying"] = toJsonValue<bool>(m_isPlaying);
+	result["PlaylistItemId"] = toJsonValue<QUuid>(m_playlistItemId);
+
 	return result;
 }
+
 QDateTime BufferRequestDto::when() const { return m_when; }
+
 void BufferRequestDto::setWhen(QDateTime newWhen) {
 	m_when = newWhen;
-	emit whenChanged(newWhen);
 }
-
 qint64 BufferRequestDto::positionTicks() const { return m_positionTicks; }
+
 void BufferRequestDto::setPositionTicks(qint64 newPositionTicks) {
 	m_positionTicks = newPositionTicks;
-	emit positionTicksChanged(newPositionTicks);
 }
-
 bool BufferRequestDto::isPlaying() const { return m_isPlaying; }
+
 void BufferRequestDto::setIsPlaying(bool newIsPlaying) {
 	m_isPlaying = newIsPlaying;
-	emit isPlayingChanged(newIsPlaying);
 }
+QUuid BufferRequestDto::playlistItemId() const { return m_playlistItemId; }
 
-QString BufferRequestDto::playlistItemId() const { return m_playlistItemId; }
-void BufferRequestDto::setPlaylistItemId(QString newPlaylistItemId) {
+void BufferRequestDto::setPlaylistItemId(QUuid newPlaylistItemId) {
 	m_playlistItemId = newPlaylistItemId;
-	emit playlistItemIdChanged(newPlaylistItemId);
 }
 
 

core/src/DTO/channelfeatures.cpp

@@ -29,99 +29,110 @@
 
 #include <JellyfinQt/DTO/channelfeatures.h>
 
-#include <JellyfinQt/DTO/channelitemsortfield.h>
-#include <JellyfinQt/DTO/channelmediacontenttype.h>
-#include <JellyfinQt/DTO/channelmediatype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ChannelFeatures::ChannelFeatures(QObject *parent) : QObject(parent) {}
+ChannelFeatures::ChannelFeatures(QObject *parent) {}
 
-ChannelFeatures *ChannelFeatures::fromJSON(QJsonObject source, QObject *parent) {
-	ChannelFeatures *instance = new ChannelFeatures(parent);
-	instance->updateFromJSON(source);
+ChannelFeatures ChannelFeatures::fromJson(QJsonObject source) {ChannelFeatures instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ChannelFeatures::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ChannelFeatures::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_canSearch = fromJsonValue<bool>(source["CanSearch"]);
+	m_mediaTypes = fromJsonValue<QList<ChannelMediaType>>(source["MediaTypes"]);
+	m_contentTypes = fromJsonValue<QList<ChannelMediaContentType>>(source["ContentTypes"]);
+	m_maxPageSize = fromJsonValue<qint32>(source["MaxPageSize"]);
+	m_autoRefreshLevels = fromJsonValue<qint32>(source["AutoRefreshLevels"]);
+	m_defaultSortFields = fromJsonValue<QList<ChannelItemSortField>>(source["DefaultSortFields"]);
+	m_supportsSortOrderToggle = fromJsonValue<bool>(source["SupportsSortOrderToggle"]);
+	m_supportsLatestMedia = fromJsonValue<bool>(source["SupportsLatestMedia"]);
+	m_canFilter = fromJsonValue<bool>(source["CanFilter"]);
+	m_supportsContentDownloading = fromJsonValue<bool>(source["SupportsContentDownloading"]);
+
 }
-QJsonObject ChannelFeatures::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ChannelFeatures::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["CanSearch"] = toJsonValue<bool>(m_canSearch);
+	result["MediaTypes"] = toJsonValue<QList<ChannelMediaType>>(m_mediaTypes);
+	result["ContentTypes"] = toJsonValue<QList<ChannelMediaContentType>>(m_contentTypes);
+	result["MaxPageSize"] = toJsonValue<qint32>(m_maxPageSize);
+	result["AutoRefreshLevels"] = toJsonValue<qint32>(m_autoRefreshLevels);
+	result["DefaultSortFields"] = toJsonValue<QList<ChannelItemSortField>>(m_defaultSortFields);
+	result["SupportsSortOrderToggle"] = toJsonValue<bool>(m_supportsSortOrderToggle);
+	result["SupportsLatestMedia"] = toJsonValue<bool>(m_supportsLatestMedia);
+	result["CanFilter"] = toJsonValue<bool>(m_canFilter);
+	result["SupportsContentDownloading"] = toJsonValue<bool>(m_supportsContentDownloading);
+
 	return result;
 }
+
 QString ChannelFeatures::name() const { return m_name; }
+
 void ChannelFeatures::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ChannelFeatures::jellyfinId() const { return m_jellyfinId; }
+
 void ChannelFeatures::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 bool ChannelFeatures::canSearch() const { return m_canSearch; }
+
 void ChannelFeatures::setCanSearch(bool newCanSearch) {
 	m_canSearch = newCanSearch;
-	emit canSearchChanged(newCanSearch);
 }
-
 QList<ChannelMediaType> ChannelFeatures::mediaTypes() const { return m_mediaTypes; }
+
 void ChannelFeatures::setMediaTypes(QList<ChannelMediaType> newMediaTypes) {
 	m_mediaTypes = newMediaTypes;
-	emit mediaTypesChanged(newMediaTypes);
 }
-
 QList<ChannelMediaContentType> ChannelFeatures::contentTypes() const { return m_contentTypes; }
+
 void ChannelFeatures::setContentTypes(QList<ChannelMediaContentType> newContentTypes) {
 	m_contentTypes = newContentTypes;
-	emit contentTypesChanged(newContentTypes);
 }
-
 qint32 ChannelFeatures::maxPageSize() const { return m_maxPageSize; }
+
 void ChannelFeatures::setMaxPageSize(qint32 newMaxPageSize) {
 	m_maxPageSize = newMaxPageSize;
-	emit maxPageSizeChanged(newMaxPageSize);
 }
-
 qint32 ChannelFeatures::autoRefreshLevels() const { return m_autoRefreshLevels; }
+
 void ChannelFeatures::setAutoRefreshLevels(qint32 newAutoRefreshLevels) {
 	m_autoRefreshLevels = newAutoRefreshLevels;
-	emit autoRefreshLevelsChanged(newAutoRefreshLevels);
 }
-
 QList<ChannelItemSortField> ChannelFeatures::defaultSortFields() const { return m_defaultSortFields; }
+
 void ChannelFeatures::setDefaultSortFields(QList<ChannelItemSortField> newDefaultSortFields) {
 	m_defaultSortFields = newDefaultSortFields;
-	emit defaultSortFieldsChanged(newDefaultSortFields);
 }
-
 bool ChannelFeatures::supportsSortOrderToggle() const { return m_supportsSortOrderToggle; }
+
 void ChannelFeatures::setSupportsSortOrderToggle(bool newSupportsSortOrderToggle) {
 	m_supportsSortOrderToggle = newSupportsSortOrderToggle;
-	emit supportsSortOrderToggleChanged(newSupportsSortOrderToggle);
 }
-
 bool ChannelFeatures::supportsLatestMedia() const { return m_supportsLatestMedia; }
+
 void ChannelFeatures::setSupportsLatestMedia(bool newSupportsLatestMedia) {
 	m_supportsLatestMedia = newSupportsLatestMedia;
-	emit supportsLatestMediaChanged(newSupportsLatestMedia);
 }
-
 bool ChannelFeatures::canFilter() const { return m_canFilter; }
+
 void ChannelFeatures::setCanFilter(bool newCanFilter) {
 	m_canFilter = newCanFilter;
-	emit canFilterChanged(newCanFilter);
 }
-
 bool ChannelFeatures::supportsContentDownloading() const { return m_supportsContentDownloading; }
+
 void ChannelFeatures::setSupportsContentDownloading(bool newSupportsContentDownloading) {
 	m_supportsContentDownloading = newSupportsContentDownloading;
-	emit supportsContentDownloadingChanged(newSupportsContentDownloading);
 }
 
 

core/src/DTO/channelmappingoptionsdto.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-ChannelMappingOptionsDto::ChannelMappingOptionsDto(QObject *parent) : QObject(parent) {}
+ChannelMappingOptionsDto::ChannelMappingOptionsDto(QObject *parent) {}
 
-ChannelMappingOptionsDto *ChannelMappingOptionsDto::fromJSON(QJsonObject source, QObject *parent) {
-	ChannelMappingOptionsDto *instance = new ChannelMappingOptionsDto(parent);
-	instance->updateFromJSON(source);
+ChannelMappingOptionsDto ChannelMappingOptionsDto::fromJson(QJsonObject source) {ChannelMappingOptionsDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ChannelMappingOptionsDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ChannelMappingOptionsDto::setFromJson(QJsonObject source) {
+	m_tunerChannels = fromJsonValue<QList<QSharedPointer<TunerChannelMapping>>>(source["TunerChannels"]);
+	m_providerChannels = fromJsonValue<QList<QSharedPointer<NameIdPair>>>(source["ProviderChannels"]);
+	m_mappings = fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["Mappings"]);
+	m_providerName = fromJsonValue<QString>(source["ProviderName"]);
+
 }
-QJsonObject ChannelMappingOptionsDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ChannelMappingOptionsDto::toJson() {
 	QJsonObject result;
+	result["TunerChannels"] = toJsonValue<QList<QSharedPointer<TunerChannelMapping>>>(m_tunerChannels);
+	result["ProviderChannels"] = toJsonValue<QList<QSharedPointer<NameIdPair>>>(m_providerChannels);
+	result["Mappings"] = toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_mappings);
+	result["ProviderName"] = toJsonValue<QString>(m_providerName);
+
 	return result;
 }
-QList<TunerChannelMapping *> ChannelMappingOptionsDto::tunerChannels() const { return m_tunerChannels; }
-void ChannelMappingOptionsDto::setTunerChannels(QList<TunerChannelMapping *> newTunerChannels) {
+
+QList<QSharedPointer<TunerChannelMapping>> ChannelMappingOptionsDto::tunerChannels() const { return m_tunerChannels; }
+
+void ChannelMappingOptionsDto::setTunerChannels(QList<QSharedPointer<TunerChannelMapping>> newTunerChannels) {
 	m_tunerChannels = newTunerChannels;
-	emit tunerChannelsChanged(newTunerChannels);
 }
+QList<QSharedPointer<NameIdPair>> ChannelMappingOptionsDto::providerChannels() const { return m_providerChannels; }
 
-QList<NameIdPair *> ChannelMappingOptionsDto::providerChannels() const { return m_providerChannels; }
-void ChannelMappingOptionsDto::setProviderChannels(QList<NameIdPair *> newProviderChannels) {
+void ChannelMappingOptionsDto::setProviderChannels(QList<QSharedPointer<NameIdPair>> newProviderChannels) {
 	m_providerChannels = newProviderChannels;
-	emit providerChannelsChanged(newProviderChannels);
 }
+QList<QSharedPointer<NameValuePair>> ChannelMappingOptionsDto::mappings() const { return m_mappings; }
 
-QList<NameValuePair *> ChannelMappingOptionsDto::mappings() const { return m_mappings; }
-void ChannelMappingOptionsDto::setMappings(QList<NameValuePair *> newMappings) {
+void ChannelMappingOptionsDto::setMappings(QList<QSharedPointer<NameValuePair>> newMappings) {
 	m_mappings = newMappings;
-	emit mappingsChanged(newMappings);
 }
-
 QString ChannelMappingOptionsDto::providerName() const { return m_providerName; }
+
 void ChannelMappingOptionsDto::setProviderName(QString newProviderName) {
 	m_providerName = newProviderName;
-	emit providerNameChanged(newProviderName);
 }
 
 

core/src/DTO/chapterinfo.cpp

@@ -32,50 +32,58 @@
 namespace Jellyfin {
 namespace DTO {
 
-ChapterInfo::ChapterInfo(QObject *parent) : QObject(parent) {}
+ChapterInfo::ChapterInfo(QObject *parent) {}
 
-ChapterInfo *ChapterInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ChapterInfo *instance = new ChapterInfo(parent);
-	instance->updateFromJSON(source);
+ChapterInfo ChapterInfo::fromJson(QJsonObject source) {ChapterInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ChapterInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ChapterInfo::setFromJson(QJsonObject source) {
+	m_startPositionTicks = fromJsonValue<qint64>(source["StartPositionTicks"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_imagePath = fromJsonValue<QString>(source["ImagePath"]);
+	m_imageDateModified = fromJsonValue<QDateTime>(source["ImageDateModified"]);
+	m_imageTag = fromJsonValue<QString>(source["ImageTag"]);
+
 }
-QJsonObject ChapterInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ChapterInfo::toJson() {
 	QJsonObject result;
+	result["StartPositionTicks"] = toJsonValue<qint64>(m_startPositionTicks);
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["ImagePath"] = toJsonValue<QString>(m_imagePath);
+	result["ImageDateModified"] = toJsonValue<QDateTime>(m_imageDateModified);
+	result["ImageTag"] = toJsonValue<QString>(m_imageTag);
+
 	return result;
 }
+
 qint64 ChapterInfo::startPositionTicks() const { return m_startPositionTicks; }
+
 void ChapterInfo::setStartPositionTicks(qint64 newStartPositionTicks) {
 	m_startPositionTicks = newStartPositionTicks;
-	emit startPositionTicksChanged(newStartPositionTicks);
 }
-
 QString ChapterInfo::name() const { return m_name; }
+
 void ChapterInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ChapterInfo::imagePath() const { return m_imagePath; }
+
 void ChapterInfo::setImagePath(QString newImagePath) {
 	m_imagePath = newImagePath;
-	emit imagePathChanged(newImagePath);
 }
-
 QDateTime ChapterInfo::imageDateModified() const { return m_imageDateModified; }
+
 void ChapterInfo::setImageDateModified(QDateTime newImageDateModified) {
 	m_imageDateModified = newImageDateModified;
-	emit imageDateModifiedChanged(newImageDateModified);
 }
-
 QString ChapterInfo::imageTag() const { return m_imageTag; }
+
 void ChapterInfo::setImageTag(QString newImageTag) {
 	m_imageTag = newImageTag;
-	emit imageTagChanged(newImageTag);
 }
 
 

core/src/DTO/clientcapabilities.cpp

@@ -29,85 +29,96 @@
 
 #include <JellyfinQt/DTO/clientcapabilities.h>
 
-#include <JellyfinQt/DTO/generalcommandtype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ClientCapabilities::ClientCapabilities(QObject *parent) : QObject(parent) {}
+ClientCapabilities::ClientCapabilities(QObject *parent) {}
 
-ClientCapabilities *ClientCapabilities::fromJSON(QJsonObject source, QObject *parent) {
-	ClientCapabilities *instance = new ClientCapabilities(parent);
-	instance->updateFromJSON(source);
+ClientCapabilities ClientCapabilities::fromJson(QJsonObject source) {ClientCapabilities instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ClientCapabilities::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ClientCapabilities::setFromJson(QJsonObject source) {
+	m_playableMediaTypes = fromJsonValue<QStringList>(source["PlayableMediaTypes"]);
+	m_supportedCommands = fromJsonValue<QList<GeneralCommandType>>(source["SupportedCommands"]);
+	m_supportsMediaControl = fromJsonValue<bool>(source["SupportsMediaControl"]);
+	m_supportsContentUploading = fromJsonValue<bool>(source["SupportsContentUploading"]);
+	m_messageCallbackUrl = fromJsonValue<QString>(source["MessageCallbackUrl"]);
+	m_supportsPersistentIdentifier = fromJsonValue<bool>(source["SupportsPersistentIdentifier"]);
+	m_supportsSync = fromJsonValue<bool>(source["SupportsSync"]);
+	m_deviceProfile = fromJsonValue<QSharedPointer<DeviceProfile>>(source["DeviceProfile"]);
+	m_appStoreUrl = fromJsonValue<QString>(source["AppStoreUrl"]);
+	m_iconUrl = fromJsonValue<QString>(source["IconUrl"]);
+
 }
-QJsonObject ClientCapabilities::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ClientCapabilities::toJson() {
 	QJsonObject result;
+	result["PlayableMediaTypes"] = toJsonValue<QStringList>(m_playableMediaTypes);
+	result["SupportedCommands"] = toJsonValue<QList<GeneralCommandType>>(m_supportedCommands);
+	result["SupportsMediaControl"] = toJsonValue<bool>(m_supportsMediaControl);
+	result["SupportsContentUploading"] = toJsonValue<bool>(m_supportsContentUploading);
+	result["MessageCallbackUrl"] = toJsonValue<QString>(m_messageCallbackUrl);
+	result["SupportsPersistentIdentifier"] = toJsonValue<bool>(m_supportsPersistentIdentifier);
+	result["SupportsSync"] = toJsonValue<bool>(m_supportsSync);
+	result["DeviceProfile"] = toJsonValue<QSharedPointer<DeviceProfile>>(m_deviceProfile);
+	result["AppStoreUrl"] = toJsonValue<QString>(m_appStoreUrl);
+	result["IconUrl"] = toJsonValue<QString>(m_iconUrl);
+
 	return result;
 }
+
 QStringList ClientCapabilities::playableMediaTypes() const { return m_playableMediaTypes; }
+
 void ClientCapabilities::setPlayableMediaTypes(QStringList newPlayableMediaTypes) {
 	m_playableMediaTypes = newPlayableMediaTypes;
-	emit playableMediaTypesChanged(newPlayableMediaTypes);
 }
-
 QList<GeneralCommandType> ClientCapabilities::supportedCommands() const { return m_supportedCommands; }
+
 void ClientCapabilities::setSupportedCommands(QList<GeneralCommandType> newSupportedCommands) {
 	m_supportedCommands = newSupportedCommands;
-	emit supportedCommandsChanged(newSupportedCommands);
 }
-
 bool ClientCapabilities::supportsMediaControl() const { return m_supportsMediaControl; }
+
 void ClientCapabilities::setSupportsMediaControl(bool newSupportsMediaControl) {
 	m_supportsMediaControl = newSupportsMediaControl;
-	emit supportsMediaControlChanged(newSupportsMediaControl);
 }
-
 bool ClientCapabilities::supportsContentUploading() const { return m_supportsContentUploading; }
+
 void ClientCapabilities::setSupportsContentUploading(bool newSupportsContentUploading) {
 	m_supportsContentUploading = newSupportsContentUploading;
-	emit supportsContentUploadingChanged(newSupportsContentUploading);
 }
-
 QString ClientCapabilities::messageCallbackUrl() const { return m_messageCallbackUrl; }
+
 void ClientCapabilities::setMessageCallbackUrl(QString newMessageCallbackUrl) {
 	m_messageCallbackUrl = newMessageCallbackUrl;
-	emit messageCallbackUrlChanged(newMessageCallbackUrl);
 }
-
 bool ClientCapabilities::supportsPersistentIdentifier() const { return m_supportsPersistentIdentifier; }
+
 void ClientCapabilities::setSupportsPersistentIdentifier(bool newSupportsPersistentIdentifier) {
 	m_supportsPersistentIdentifier = newSupportsPersistentIdentifier;
-	emit supportsPersistentIdentifierChanged(newSupportsPersistentIdentifier);
 }
-
 bool ClientCapabilities::supportsSync() const { return m_supportsSync; }
+
 void ClientCapabilities::setSupportsSync(bool newSupportsSync) {
 	m_supportsSync = newSupportsSync;
-	emit supportsSyncChanged(newSupportsSync);
 }
+QSharedPointer<DeviceProfile> ClientCapabilities::deviceProfile() const { return m_deviceProfile; }
 
-DeviceProfile * ClientCapabilities::deviceProfile() const { return m_deviceProfile; }
-void ClientCapabilities::setDeviceProfile(DeviceProfile * newDeviceProfile) {
+void ClientCapabilities::setDeviceProfile(QSharedPointer<DeviceProfile> newDeviceProfile) {
 	m_deviceProfile = newDeviceProfile;
-	emit deviceProfileChanged(newDeviceProfile);
 }
-
 QString ClientCapabilities::appStoreUrl() const { return m_appStoreUrl; }
+
 void ClientCapabilities::setAppStoreUrl(QString newAppStoreUrl) {
 	m_appStoreUrl = newAppStoreUrl;
-	emit appStoreUrlChanged(newAppStoreUrl);
 }
-
 QString ClientCapabilities::iconUrl() const { return m_iconUrl; }
+
 void ClientCapabilities::setIconUrl(QString newIconUrl) {
 	m_iconUrl = newIconUrl;
-	emit iconUrlChanged(newIconUrl);
 }
 
 

core/src/DTO/clientcapabilitiesdto.cpp

@@ -29,85 +29,96 @@
 
 #include <JellyfinQt/DTO/clientcapabilitiesdto.h>
 
-#include <JellyfinQt/DTO/generalcommandtype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ClientCapabilitiesDto::ClientCapabilitiesDto(QObject *parent) : QObject(parent) {}
+ClientCapabilitiesDto::ClientCapabilitiesDto(QObject *parent) {}
 
-ClientCapabilitiesDto *ClientCapabilitiesDto::fromJSON(QJsonObject source, QObject *parent) {
-	ClientCapabilitiesDto *instance = new ClientCapabilitiesDto(parent);
-	instance->updateFromJSON(source);
+ClientCapabilitiesDto ClientCapabilitiesDto::fromJson(QJsonObject source) {ClientCapabilitiesDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ClientCapabilitiesDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ClientCapabilitiesDto::setFromJson(QJsonObject source) {
+	m_playableMediaTypes = fromJsonValue<QStringList>(source["PlayableMediaTypes"]);
+	m_supportedCommands = fromJsonValue<QList<GeneralCommandType>>(source["SupportedCommands"]);
+	m_supportsMediaControl = fromJsonValue<bool>(source["SupportsMediaControl"]);
+	m_supportsContentUploading = fromJsonValue<bool>(source["SupportsContentUploading"]);
+	m_messageCallbackUrl = fromJsonValue<QString>(source["MessageCallbackUrl"]);
+	m_supportsPersistentIdentifier = fromJsonValue<bool>(source["SupportsPersistentIdentifier"]);
+	m_supportsSync = fromJsonValue<bool>(source["SupportsSync"]);
+	m_deviceProfile = fromJsonValue<QSharedPointer<DeviceProfile>>(source["DeviceProfile"]);
+	m_appStoreUrl = fromJsonValue<QString>(source["AppStoreUrl"]);
+	m_iconUrl = fromJsonValue<QString>(source["IconUrl"]);
+
 }
-QJsonObject ClientCapabilitiesDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ClientCapabilitiesDto::toJson() {
 	QJsonObject result;
+	result["PlayableMediaTypes"] = toJsonValue<QStringList>(m_playableMediaTypes);
+	result["SupportedCommands"] = toJsonValue<QList<GeneralCommandType>>(m_supportedCommands);
+	result["SupportsMediaControl"] = toJsonValue<bool>(m_supportsMediaControl);
+	result["SupportsContentUploading"] = toJsonValue<bool>(m_supportsContentUploading);
+	result["MessageCallbackUrl"] = toJsonValue<QString>(m_messageCallbackUrl);
+	result["SupportsPersistentIdentifier"] = toJsonValue<bool>(m_supportsPersistentIdentifier);
+	result["SupportsSync"] = toJsonValue<bool>(m_supportsSync);
+	result["DeviceProfile"] = toJsonValue<QSharedPointer<DeviceProfile>>(m_deviceProfile);
+	result["AppStoreUrl"] = toJsonValue<QString>(m_appStoreUrl);
+	result["IconUrl"] = toJsonValue<QString>(m_iconUrl);
+
 	return result;
 }
+
 QStringList ClientCapabilitiesDto::playableMediaTypes() const { return m_playableMediaTypes; }
+
 void ClientCapabilitiesDto::setPlayableMediaTypes(QStringList newPlayableMediaTypes) {
 	m_playableMediaTypes = newPlayableMediaTypes;
-	emit playableMediaTypesChanged(newPlayableMediaTypes);
 }
-
 QList<GeneralCommandType> ClientCapabilitiesDto::supportedCommands() const { return m_supportedCommands; }
+
 void ClientCapabilitiesDto::setSupportedCommands(QList<GeneralCommandType> newSupportedCommands) {
 	m_supportedCommands = newSupportedCommands;
-	emit supportedCommandsChanged(newSupportedCommands);
 }
-
 bool ClientCapabilitiesDto::supportsMediaControl() const { return m_supportsMediaControl; }
+
 void ClientCapabilitiesDto::setSupportsMediaControl(bool newSupportsMediaControl) {
 	m_supportsMediaControl = newSupportsMediaControl;
-	emit supportsMediaControlChanged(newSupportsMediaControl);
 }
-
 bool ClientCapabilitiesDto::supportsContentUploading() const { return m_supportsContentUploading; }
+
 void ClientCapabilitiesDto::setSupportsContentUploading(bool newSupportsContentUploading) {
 	m_supportsContentUploading = newSupportsContentUploading;
-	emit supportsContentUploadingChanged(newSupportsContentUploading);
 }
-
 QString ClientCapabilitiesDto::messageCallbackUrl() const { return m_messageCallbackUrl; }
+
 void ClientCapabilitiesDto::setMessageCallbackUrl(QString newMessageCallbackUrl) {
 	m_messageCallbackUrl = newMessageCallbackUrl;
-	emit messageCallbackUrlChanged(newMessageCallbackUrl);
 }
-
 bool ClientCapabilitiesDto::supportsPersistentIdentifier() const { return m_supportsPersistentIdentifier; }
+
 void ClientCapabilitiesDto::setSupportsPersistentIdentifier(bool newSupportsPersistentIdentifier) {
 	m_supportsPersistentIdentifier = newSupportsPersistentIdentifier;
-	emit supportsPersistentIdentifierChanged(newSupportsPersistentIdentifier);
 }
-
 bool ClientCapabilitiesDto::supportsSync() const { return m_supportsSync; }
+
 void ClientCapabilitiesDto::setSupportsSync(bool newSupportsSync) {
 	m_supportsSync = newSupportsSync;
-	emit supportsSyncChanged(newSupportsSync);
 }
+QSharedPointer<DeviceProfile> ClientCapabilitiesDto::deviceProfile() const { return m_deviceProfile; }
 
-DeviceProfile * ClientCapabilitiesDto::deviceProfile() const { return m_deviceProfile; }
-void ClientCapabilitiesDto::setDeviceProfile(DeviceProfile * newDeviceProfile) {
+void ClientCapabilitiesDto::setDeviceProfile(QSharedPointer<DeviceProfile> newDeviceProfile) {
 	m_deviceProfile = newDeviceProfile;
-	emit deviceProfileChanged(newDeviceProfile);
 }
-
 QString ClientCapabilitiesDto::appStoreUrl() const { return m_appStoreUrl; }
+
 void ClientCapabilitiesDto::setAppStoreUrl(QString newAppStoreUrl) {
 	m_appStoreUrl = newAppStoreUrl;
-	emit appStoreUrlChanged(newAppStoreUrl);
 }
-
 QString ClientCapabilitiesDto::iconUrl() const { return m_iconUrl; }
+
 void ClientCapabilitiesDto::setIconUrl(QString newIconUrl) {
 	m_iconUrl = newIconUrl;
-	emit iconUrlChanged(newIconUrl);
 }
 
 

core/src/DTO/codecprofile.cpp

@@ -29,55 +29,61 @@
 
 #include <JellyfinQt/DTO/codecprofile.h>
 
-#include <JellyfinQt/DTO/codectype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-CodecProfile::CodecProfile(QObject *parent) : QObject(parent) {}
+CodecProfile::CodecProfile(QObject *parent) {}
 
-CodecProfile *CodecProfile::fromJSON(QJsonObject source, QObject *parent) {
-	CodecProfile *instance = new CodecProfile(parent);
-	instance->updateFromJSON(source);
+CodecProfile CodecProfile::fromJson(QJsonObject source) {CodecProfile instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void CodecProfile::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void CodecProfile::setFromJson(QJsonObject source) {
+	m_type = fromJsonValue<CodecType>(source["Type"]);
+	m_conditions = fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["Conditions"]);
+	m_applyConditions = fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["ApplyConditions"]);
+	m_codec = fromJsonValue<QString>(source["Codec"]);
+	m_container = fromJsonValue<QString>(source["Container"]);
+
 }
-QJsonObject CodecProfile::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject CodecProfile::toJson() {
 	QJsonObject result;
+	result["Type"] = toJsonValue<CodecType>(m_type);
+	result["Conditions"] = toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_conditions);
+	result["ApplyConditions"] = toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_applyConditions);
+	result["Codec"] = toJsonValue<QString>(m_codec);
+	result["Container"] = toJsonValue<QString>(m_container);
+
 	return result;
 }
+
 CodecType CodecProfile::type() const { return m_type; }
+
 void CodecProfile::setType(CodecType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
+QList<QSharedPointer<ProfileCondition>> CodecProfile::conditions() const { return m_conditions; }
 
-QList<ProfileCondition *> CodecProfile::conditions() const { return m_conditions; }
-void CodecProfile::setConditions(QList<ProfileCondition *> newConditions) {
+void CodecProfile::setConditions(QList<QSharedPointer<ProfileCondition>> newConditions) {
 	m_conditions = newConditions;
-	emit conditionsChanged(newConditions);
 }
+QList<QSharedPointer<ProfileCondition>> CodecProfile::applyConditions() const { return m_applyConditions; }
 
-QList<ProfileCondition *> CodecProfile::applyConditions() const { return m_applyConditions; }
-void CodecProfile::setApplyConditions(QList<ProfileCondition *> newApplyConditions) {
+void CodecProfile::setApplyConditions(QList<QSharedPointer<ProfileCondition>> newApplyConditions) {
 	m_applyConditions = newApplyConditions;
-	emit applyConditionsChanged(newApplyConditions);
 }
-
 QString CodecProfile::codec() const { return m_codec; }
+
 void CodecProfile::setCodec(QString newCodec) {
 	m_codec = newCodec;
-	emit codecChanged(newCodec);
 }
-
 QString CodecProfile::container() const { return m_container; }
+
 void CodecProfile::setContainer(QString newContainer) {
 	m_container = newContainer;
-	emit containerChanged(newContainer);
 }
 
 

core/src/DTO/collectioncreationresult.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-CollectionCreationResult::CollectionCreationResult(QObject *parent) : QObject(parent) {}
+CollectionCreationResult::CollectionCreationResult(QObject *parent) {}
 
-CollectionCreationResult *CollectionCreationResult::fromJSON(QJsonObject source, QObject *parent) {
-	CollectionCreationResult *instance = new CollectionCreationResult(parent);
-	instance->updateFromJSON(source);
+CollectionCreationResult CollectionCreationResult::fromJson(QJsonObject source) {CollectionCreationResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void CollectionCreationResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void CollectionCreationResult::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<QUuid>(source["Id"]);
+
 }
-QJsonObject CollectionCreationResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject CollectionCreationResult::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<QUuid>(m_jellyfinId);
+
 	return result;
 }
-QString CollectionCreationResult::jellyfinId() const { return m_jellyfinId; }
-void CollectionCreationResult::setJellyfinId(QString newJellyfinId) {
+
+QUuid CollectionCreationResult::jellyfinId() const { return m_jellyfinId; }
+
+void CollectionCreationResult::setJellyfinId(QUuid newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
 
 

core/src/DTO/configurationpageinfo.cpp

@@ -29,67 +29,75 @@
 
 #include <JellyfinQt/DTO/configurationpageinfo.h>
 
-#include <JellyfinQt/DTO/configurationpagetype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ConfigurationPageInfo::ConfigurationPageInfo(QObject *parent) : QObject(parent) {}
+ConfigurationPageInfo::ConfigurationPageInfo(QObject *parent) {}
 
-ConfigurationPageInfo *ConfigurationPageInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ConfigurationPageInfo *instance = new ConfigurationPageInfo(parent);
-	instance->updateFromJSON(source);
+ConfigurationPageInfo ConfigurationPageInfo::fromJson(QJsonObject source) {ConfigurationPageInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ConfigurationPageInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ConfigurationPageInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_enableInMainMenu = fromJsonValue<bool>(source["EnableInMainMenu"]);
+	m_menuSection = fromJsonValue<QString>(source["MenuSection"]);
+	m_menuIcon = fromJsonValue<QString>(source["MenuIcon"]);
+	m_displayName = fromJsonValue<QString>(source["DisplayName"]);
+	m_configurationPageType = fromJsonValue<ConfigurationPageType>(source["ConfigurationPageType"]);
+	m_pluginId = fromJsonValue<QUuid>(source["PluginId"]);
+
 }
-QJsonObject ConfigurationPageInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ConfigurationPageInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["EnableInMainMenu"] = toJsonValue<bool>(m_enableInMainMenu);
+	result["MenuSection"] = toJsonValue<QString>(m_menuSection);
+	result["MenuIcon"] = toJsonValue<QString>(m_menuIcon);
+	result["DisplayName"] = toJsonValue<QString>(m_displayName);
+	result["ConfigurationPageType"] = toJsonValue<ConfigurationPageType>(m_configurationPageType);
+	result["PluginId"] = toJsonValue<QUuid>(m_pluginId);
+
 	return result;
 }
+
 QString ConfigurationPageInfo::name() const { return m_name; }
+
 void ConfigurationPageInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 bool ConfigurationPageInfo::enableInMainMenu() const { return m_enableInMainMenu; }
+
 void ConfigurationPageInfo::setEnableInMainMenu(bool newEnableInMainMenu) {
 	m_enableInMainMenu = newEnableInMainMenu;
-	emit enableInMainMenuChanged(newEnableInMainMenu);
 }
-
 QString ConfigurationPageInfo::menuSection() const { return m_menuSection; }
+
 void ConfigurationPageInfo::setMenuSection(QString newMenuSection) {
 	m_menuSection = newMenuSection;
-	emit menuSectionChanged(newMenuSection);
 }
-
 QString ConfigurationPageInfo::menuIcon() const { return m_menuIcon; }
+
 void ConfigurationPageInfo::setMenuIcon(QString newMenuIcon) {
 	m_menuIcon = newMenuIcon;
-	emit menuIconChanged(newMenuIcon);
 }
-
 QString ConfigurationPageInfo::displayName() const { return m_displayName; }
+
 void ConfigurationPageInfo::setDisplayName(QString newDisplayName) {
 	m_displayName = newDisplayName;
-	emit displayNameChanged(newDisplayName);
 }
-
 ConfigurationPageType ConfigurationPageInfo::configurationPageType() const { return m_configurationPageType; }
+
 void ConfigurationPageInfo::setConfigurationPageType(ConfigurationPageType newConfigurationPageType) {
 	m_configurationPageType = newConfigurationPageType;
-	emit configurationPageTypeChanged(newConfigurationPageType);
 }
+QUuid ConfigurationPageInfo::pluginId() const { return m_pluginId; }
 
-QString ConfigurationPageInfo::pluginId() const { return m_pluginId; }
-void ConfigurationPageInfo::setPluginId(QString newPluginId) {
+void ConfigurationPageInfo::setPluginId(QUuid newPluginId) {
 	m_pluginId = newPluginId;
-	emit pluginIdChanged(newPluginId);
 }
 
 

core/src/DTO/containerprofile.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/containerprofile.h>
 
-#include <JellyfinQt/DTO/dlnaprofiletype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ContainerProfile::ContainerProfile(QObject *parent) : QObject(parent) {}
+ContainerProfile::ContainerProfile(QObject *parent) {}
 
-ContainerProfile *ContainerProfile::fromJSON(QJsonObject source, QObject *parent) {
-	ContainerProfile *instance = new ContainerProfile(parent);
-	instance->updateFromJSON(source);
+ContainerProfile ContainerProfile::fromJson(QJsonObject source) {ContainerProfile instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ContainerProfile::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ContainerProfile::setFromJson(QJsonObject source) {
+	m_type = fromJsonValue<DlnaProfileType>(source["Type"]);
+	m_conditions = fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["Conditions"]);
+	m_container = fromJsonValue<QString>(source["Container"]);
+
 }
-QJsonObject ContainerProfile::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ContainerProfile::toJson() {
 	QJsonObject result;
+	result["Type"] = toJsonValue<DlnaProfileType>(m_type);
+	result["Conditions"] = toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_conditions);
+	result["Container"] = toJsonValue<QString>(m_container);
+
 	return result;
 }
+
 DlnaProfileType ContainerProfile::type() const { return m_type; }
+
 void ContainerProfile::setType(DlnaProfileType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
+QList<QSharedPointer<ProfileCondition>> ContainerProfile::conditions() const { return m_conditions; }
 
-QList<ProfileCondition *> ContainerProfile::conditions() const { return m_conditions; }
-void ContainerProfile::setConditions(QList<ProfileCondition *> newConditions) {
+void ContainerProfile::setConditions(QList<QSharedPointer<ProfileCondition>> newConditions) {
 	m_conditions = newConditions;
-	emit conditionsChanged(newConditions);
 }
-
 QString ContainerProfile::container() const { return m_container; }
+
 void ContainerProfile::setContainer(QString newContainer) {
 	m_container = newContainer;
-	emit containerChanged(newContainer);
 }
 
 

core/src/DTO/controlresponse.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-ControlResponse::ControlResponse(QObject *parent) : QObject(parent) {}
+ControlResponse::ControlResponse(QObject *parent) {}
 
-ControlResponse *ControlResponse::fromJSON(QJsonObject source, QObject *parent) {
-	ControlResponse *instance = new ControlResponse(parent);
-	instance->updateFromJSON(source);
+ControlResponse ControlResponse::fromJson(QJsonObject source) {ControlResponse instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ControlResponse::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ControlResponse::setFromJson(QJsonObject source) {
+	m_headers = fromJsonValue<QJsonObject>(source["Headers"]);
+	m_xml = fromJsonValue<QString>(source["Xml"]);
+	m_isSuccessful = fromJsonValue<bool>(source["IsSuccessful"]);
+
 }
-QJsonObject ControlResponse::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ControlResponse::toJson() {
 	QJsonObject result;
+	result["Headers"] = toJsonValue<QJsonObject>(m_headers);
+	result["Xml"] = toJsonValue<QString>(m_xml);
+	result["IsSuccessful"] = toJsonValue<bool>(m_isSuccessful);
+
 	return result;
 }
+
 QJsonObject ControlResponse::headers() const { return m_headers; }
+
 void ControlResponse::setHeaders(QJsonObject newHeaders) {
 	m_headers = newHeaders;
-	emit headersChanged(newHeaders);
 }
-
 QString ControlResponse::xml() const { return m_xml; }
+
 void ControlResponse::setXml(QString newXml) {
 	m_xml = newXml;
-	emit xmlChanged(newXml);
 }
-
 bool ControlResponse::isSuccessful() const { return m_isSuccessful; }
+
 void ControlResponse::setIsSuccessful(bool newIsSuccessful) {
 	m_isSuccessful = newIsSuccessful;
-	emit isSuccessfulChanged(newIsSuccessful);
 }
 
 

core/src/DTO/countryinfo.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-CountryInfo::CountryInfo(QObject *parent) : QObject(parent) {}
+CountryInfo::CountryInfo(QObject *parent) {}
 
-CountryInfo *CountryInfo::fromJSON(QJsonObject source, QObject *parent) {
-	CountryInfo *instance = new CountryInfo(parent);
-	instance->updateFromJSON(source);
+CountryInfo CountryInfo::fromJson(QJsonObject source) {CountryInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void CountryInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void CountryInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_displayName = fromJsonValue<QString>(source["DisplayName"]);
+	m_twoLetterISORegionName = fromJsonValue<QString>(source["TwoLetterISORegionName"]);
+	m_threeLetterISORegionName = fromJsonValue<QString>(source["ThreeLetterISORegionName"]);
+
 }
-QJsonObject CountryInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject CountryInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["DisplayName"] = toJsonValue<QString>(m_displayName);
+	result["TwoLetterISORegionName"] = toJsonValue<QString>(m_twoLetterISORegionName);
+	result["ThreeLetterISORegionName"] = toJsonValue<QString>(m_threeLetterISORegionName);
+
 	return result;
 }
+
 QString CountryInfo::name() const { return m_name; }
+
 void CountryInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString CountryInfo::displayName() const { return m_displayName; }
+
 void CountryInfo::setDisplayName(QString newDisplayName) {
 	m_displayName = newDisplayName;
-	emit displayNameChanged(newDisplayName);
 }
-
 QString CountryInfo::twoLetterISORegionName() const { return m_twoLetterISORegionName; }
+
 void CountryInfo::setTwoLetterISORegionName(QString newTwoLetterISORegionName) {
 	m_twoLetterISORegionName = newTwoLetterISORegionName;
-	emit twoLetterISORegionNameChanged(newTwoLetterISORegionName);
 }
-
 QString CountryInfo::threeLetterISORegionName() const { return m_threeLetterISORegionName; }
+
 void CountryInfo::setThreeLetterISORegionName(QString newThreeLetterISORegionName) {
 	m_threeLetterISORegionName = newThreeLetterISORegionName;
-	emit threeLetterISORegionNameChanged(newThreeLetterISORegionName);
 }
 
 

core/src/DTO/createplaylistdto.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-CreatePlaylistDto::CreatePlaylistDto(QObject *parent) : QObject(parent) {}
+CreatePlaylistDto::CreatePlaylistDto(QObject *parent) {}
 
-CreatePlaylistDto *CreatePlaylistDto::fromJSON(QJsonObject source, QObject *parent) {
-	CreatePlaylistDto *instance = new CreatePlaylistDto(parent);
-	instance->updateFromJSON(source);
+CreatePlaylistDto CreatePlaylistDto::fromJson(QJsonObject source) {CreatePlaylistDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void CreatePlaylistDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void CreatePlaylistDto::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_ids = fromJsonValue<QList<QUuid>>(source["Ids"]);
+	m_userId = fromJsonValue<QUuid>(source["UserId"]);
+	m_mediaType = fromJsonValue<QString>(source["MediaType"]);
+
 }
-QJsonObject CreatePlaylistDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject CreatePlaylistDto::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Ids"] = toJsonValue<QList<QUuid>>(m_ids);
+	result["UserId"] = toJsonValue<QUuid>(m_userId);
+	result["MediaType"] = toJsonValue<QString>(m_mediaType);
+
 	return result;
 }
+
 QString CreatePlaylistDto::name() const { return m_name; }
+
 void CreatePlaylistDto::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
+QList<QUuid> CreatePlaylistDto::ids() const { return m_ids; }
 
-QStringList CreatePlaylistDto::ids() const { return m_ids; }
-void CreatePlaylistDto::setIds(QStringList newIds) {
+void CreatePlaylistDto::setIds(QList<QUuid> newIds) {
 	m_ids = newIds;
-	emit idsChanged(newIds);
 }
+QUuid CreatePlaylistDto::userId() const { return m_userId; }
 
-QString CreatePlaylistDto::userId() const { return m_userId; }
-void CreatePlaylistDto::setUserId(QString newUserId) {
+void CreatePlaylistDto::setUserId(QUuid newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 QString CreatePlaylistDto::mediaType() const { return m_mediaType; }
+
 void CreatePlaylistDto::setMediaType(QString newMediaType) {
 	m_mediaType = newMediaType;
-	emit mediaTypeChanged(newMediaType);
 }
 
 

core/src/DTO/createuserbyname.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-CreateUserByName::CreateUserByName(QObject *parent) : QObject(parent) {}
+CreateUserByName::CreateUserByName(QObject *parent) {}
 
-CreateUserByName *CreateUserByName::fromJSON(QJsonObject source, QObject *parent) {
-	CreateUserByName *instance = new CreateUserByName(parent);
-	instance->updateFromJSON(source);
+CreateUserByName CreateUserByName::fromJson(QJsonObject source) {CreateUserByName instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void CreateUserByName::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void CreateUserByName::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_password = fromJsonValue<QString>(source["Password"]);
+
 }
-QJsonObject CreateUserByName::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject CreateUserByName::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Password"] = toJsonValue<QString>(m_password);
+
 	return result;
 }
+
 QString CreateUserByName::name() const { return m_name; }
+
 void CreateUserByName::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString CreateUserByName::password() const { return m_password; }
+
 void CreateUserByName::setPassword(QString newPassword) {
 	m_password = newPassword;
-	emit passwordChanged(newPassword);
 }
 
 

core/src/DTO/culturedto.cpp

@@ -32,50 +32,58 @@
 namespace Jellyfin {
 namespace DTO {
 
-CultureDto::CultureDto(QObject *parent) : QObject(parent) {}
+CultureDto::CultureDto(QObject *parent) {}
 
-CultureDto *CultureDto::fromJSON(QJsonObject source, QObject *parent) {
-	CultureDto *instance = new CultureDto(parent);
-	instance->updateFromJSON(source);
+CultureDto CultureDto::fromJson(QJsonObject source) {CultureDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void CultureDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void CultureDto::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_displayName = fromJsonValue<QString>(source["DisplayName"]);
+	m_twoLetterISOLanguageName = fromJsonValue<QString>(source["TwoLetterISOLanguageName"]);
+	m_threeLetterISOLanguageName = fromJsonValue<QString>(source["ThreeLetterISOLanguageName"]);
+	m_threeLetterISOLanguageNames = fromJsonValue<QStringList>(source["ThreeLetterISOLanguageNames"]);
+
 }
-QJsonObject CultureDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject CultureDto::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["DisplayName"] = toJsonValue<QString>(m_displayName);
+	result["TwoLetterISOLanguageName"] = toJsonValue<QString>(m_twoLetterISOLanguageName);
+	result["ThreeLetterISOLanguageName"] = toJsonValue<QString>(m_threeLetterISOLanguageName);
+	result["ThreeLetterISOLanguageNames"] = toJsonValue<QStringList>(m_threeLetterISOLanguageNames);
+
 	return result;
 }
+
 QString CultureDto::name() const { return m_name; }
+
 void CultureDto::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString CultureDto::displayName() const { return m_displayName; }
+
 void CultureDto::setDisplayName(QString newDisplayName) {
 	m_displayName = newDisplayName;
-	emit displayNameChanged(newDisplayName);
 }
-
 QString CultureDto::twoLetterISOLanguageName() const { return m_twoLetterISOLanguageName; }
+
 void CultureDto::setTwoLetterISOLanguageName(QString newTwoLetterISOLanguageName) {
 	m_twoLetterISOLanguageName = newTwoLetterISOLanguageName;
-	emit twoLetterISOLanguageNameChanged(newTwoLetterISOLanguageName);
 }
-
 QString CultureDto::threeLetterISOLanguageName() const { return m_threeLetterISOLanguageName; }
+
 void CultureDto::setThreeLetterISOLanguageName(QString newThreeLetterISOLanguageName) {
 	m_threeLetterISOLanguageName = newThreeLetterISOLanguageName;
-	emit threeLetterISOLanguageNameChanged(newThreeLetterISOLanguageName);
 }
-
 QStringList CultureDto::threeLetterISOLanguageNames() const { return m_threeLetterISOLanguageNames; }
+
 void CultureDto::setThreeLetterISOLanguageNames(QStringList newThreeLetterISOLanguageNames) {
 	m_threeLetterISOLanguageNames = newThreeLetterISOLanguageNames;
-	emit threeLetterISOLanguageNamesChanged(newThreeLetterISOLanguageNames);
 }
 
 

core/src/DTO/defaultdirectorybrowserinfodto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-DefaultDirectoryBrowserInfoDto::DefaultDirectoryBrowserInfoDto(QObject *parent) : QObject(parent) {}
+DefaultDirectoryBrowserInfoDto::DefaultDirectoryBrowserInfoDto(QObject *parent) {}
 
-DefaultDirectoryBrowserInfoDto *DefaultDirectoryBrowserInfoDto::fromJSON(QJsonObject source, QObject *parent) {
-	DefaultDirectoryBrowserInfoDto *instance = new DefaultDirectoryBrowserInfoDto(parent);
-	instance->updateFromJSON(source);
+DefaultDirectoryBrowserInfoDto DefaultDirectoryBrowserInfoDto::fromJson(QJsonObject source) {DefaultDirectoryBrowserInfoDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DefaultDirectoryBrowserInfoDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DefaultDirectoryBrowserInfoDto::setFromJson(QJsonObject source) {
+	m_path = fromJsonValue<QString>(source["Path"]);
+
 }
-QJsonObject DefaultDirectoryBrowserInfoDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DefaultDirectoryBrowserInfoDto::toJson() {
 	QJsonObject result;
+	result["Path"] = toJsonValue<QString>(m_path);
+
 	return result;
 }
+
 QString DefaultDirectoryBrowserInfoDto::path() const { return m_path; }
+
 void DefaultDirectoryBrowserInfoDto::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
 
 

core/src/DTO/deviceidentification.cpp

@@ -32,74 +32,86 @@
 namespace Jellyfin {
 namespace DTO {
 
-DeviceIdentification::DeviceIdentification(QObject *parent) : QObject(parent) {}
+DeviceIdentification::DeviceIdentification(QObject *parent) {}
 
-DeviceIdentification *DeviceIdentification::fromJSON(QJsonObject source, QObject *parent) {
-	DeviceIdentification *instance = new DeviceIdentification(parent);
-	instance->updateFromJSON(source);
+DeviceIdentification DeviceIdentification::fromJson(QJsonObject source) {DeviceIdentification instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DeviceIdentification::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DeviceIdentification::setFromJson(QJsonObject source) {
+	m_friendlyName = fromJsonValue<QString>(source["FriendlyName"]);
+	m_modelNumber = fromJsonValue<QString>(source["ModelNumber"]);
+	m_serialNumber = fromJsonValue<QString>(source["SerialNumber"]);
+	m_modelName = fromJsonValue<QString>(source["ModelName"]);
+	m_modelDescription = fromJsonValue<QString>(source["ModelDescription"]);
+	m_modelUrl = fromJsonValue<QString>(source["ModelUrl"]);
+	m_manufacturer = fromJsonValue<QString>(source["Manufacturer"]);
+	m_manufacturerUrl = fromJsonValue<QString>(source["ManufacturerUrl"]);
+	m_headers = fromJsonValue<QList<QSharedPointer<HttpHeaderInfo>>>(source["Headers"]);
+
 }
-QJsonObject DeviceIdentification::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DeviceIdentification::toJson() {
 	QJsonObject result;
+	result["FriendlyName"] = toJsonValue<QString>(m_friendlyName);
+	result["ModelNumber"] = toJsonValue<QString>(m_modelNumber);
+	result["SerialNumber"] = toJsonValue<QString>(m_serialNumber);
+	result["ModelName"] = toJsonValue<QString>(m_modelName);
+	result["ModelDescription"] = toJsonValue<QString>(m_modelDescription);
+	result["ModelUrl"] = toJsonValue<QString>(m_modelUrl);
+	result["Manufacturer"] = toJsonValue<QString>(m_manufacturer);
+	result["ManufacturerUrl"] = toJsonValue<QString>(m_manufacturerUrl);
+	result["Headers"] = toJsonValue<QList<QSharedPointer<HttpHeaderInfo>>>(m_headers);
+
 	return result;
 }
+
 QString DeviceIdentification::friendlyName() const { return m_friendlyName; }
+
 void DeviceIdentification::setFriendlyName(QString newFriendlyName) {
 	m_friendlyName = newFriendlyName;
-	emit friendlyNameChanged(newFriendlyName);
 }
-
 QString DeviceIdentification::modelNumber() const { return m_modelNumber; }
+
 void DeviceIdentification::setModelNumber(QString newModelNumber) {
 	m_modelNumber = newModelNumber;
-	emit modelNumberChanged(newModelNumber);
 }
-
 QString DeviceIdentification::serialNumber() const { return m_serialNumber; }
+
 void DeviceIdentification::setSerialNumber(QString newSerialNumber) {
 	m_serialNumber = newSerialNumber;
-	emit serialNumberChanged(newSerialNumber);
 }
-
 QString DeviceIdentification::modelName() const { return m_modelName; }
+
 void DeviceIdentification::setModelName(QString newModelName) {
 	m_modelName = newModelName;
-	emit modelNameChanged(newModelName);
 }
-
 QString DeviceIdentification::modelDescription() const { return m_modelDescription; }
+
 void DeviceIdentification::setModelDescription(QString newModelDescription) {
 	m_modelDescription = newModelDescription;
-	emit modelDescriptionChanged(newModelDescription);
 }
-
 QString DeviceIdentification::modelUrl() const { return m_modelUrl; }
+
 void DeviceIdentification::setModelUrl(QString newModelUrl) {
 	m_modelUrl = newModelUrl;
-	emit modelUrlChanged(newModelUrl);
 }
-
 QString DeviceIdentification::manufacturer() const { return m_manufacturer; }
+
 void DeviceIdentification::setManufacturer(QString newManufacturer) {
 	m_manufacturer = newManufacturer;
-	emit manufacturerChanged(newManufacturer);
 }
-
 QString DeviceIdentification::manufacturerUrl() const { return m_manufacturerUrl; }
+
 void DeviceIdentification::setManufacturerUrl(QString newManufacturerUrl) {
 	m_manufacturerUrl = newManufacturerUrl;
-	emit manufacturerUrlChanged(newManufacturerUrl);
 }
+QList<QSharedPointer<HttpHeaderInfo>> DeviceIdentification::headers() const { return m_headers; }
 
-QList<HttpHeaderInfo *> DeviceIdentification::headers() const { return m_headers; }
-void DeviceIdentification::setHeaders(QList<HttpHeaderInfo *> newHeaders) {
+void DeviceIdentification::setHeaders(QList<QSharedPointer<HttpHeaderInfo>> newHeaders) {
 	m_headers = newHeaders;
-	emit headersChanged(newHeaders);
 }
 
 

core/src/DTO/deviceinfo.cpp

@@ -32,74 +32,86 @@
 namespace Jellyfin {
 namespace DTO {
 
-DeviceInfo::DeviceInfo(QObject *parent) : QObject(parent) {}
+DeviceInfo::DeviceInfo(QObject *parent) {}
 
-DeviceInfo *DeviceInfo::fromJSON(QJsonObject source, QObject *parent) {
-	DeviceInfo *instance = new DeviceInfo(parent);
-	instance->updateFromJSON(source);
+DeviceInfo DeviceInfo::fromJson(QJsonObject source) {DeviceInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DeviceInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DeviceInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_lastUserName = fromJsonValue<QString>(source["LastUserName"]);
+	m_appName = fromJsonValue<QString>(source["AppName"]);
+	m_appVersion = fromJsonValue<QString>(source["AppVersion"]);
+	m_lastUserId = fromJsonValue<QUuid>(source["LastUserId"]);
+	m_dateLastActivity = fromJsonValue<QDateTime>(source["DateLastActivity"]);
+	m_capabilities = fromJsonValue<QSharedPointer<ClientCapabilities>>(source["Capabilities"]);
+	m_iconUrl = fromJsonValue<QString>(source["IconUrl"]);
+
 }
-QJsonObject DeviceInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DeviceInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["LastUserName"] = toJsonValue<QString>(m_lastUserName);
+	result["AppName"] = toJsonValue<QString>(m_appName);
+	result["AppVersion"] = toJsonValue<QString>(m_appVersion);
+	result["LastUserId"] = toJsonValue<QUuid>(m_lastUserId);
+	result["DateLastActivity"] = toJsonValue<QDateTime>(m_dateLastActivity);
+	result["Capabilities"] = toJsonValue<QSharedPointer<ClientCapabilities>>(m_capabilities);
+	result["IconUrl"] = toJsonValue<QString>(m_iconUrl);
+
 	return result;
 }
+
 QString DeviceInfo::name() const { return m_name; }
+
 void DeviceInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString DeviceInfo::jellyfinId() const { return m_jellyfinId; }
+
 void DeviceInfo::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString DeviceInfo::lastUserName() const { return m_lastUserName; }
+
 void DeviceInfo::setLastUserName(QString newLastUserName) {
 	m_lastUserName = newLastUserName;
-	emit lastUserNameChanged(newLastUserName);
 }
-
 QString DeviceInfo::appName() const { return m_appName; }
+
 void DeviceInfo::setAppName(QString newAppName) {
 	m_appName = newAppName;
-	emit appNameChanged(newAppName);
 }
-
 QString DeviceInfo::appVersion() const { return m_appVersion; }
+
 void DeviceInfo::setAppVersion(QString newAppVersion) {
 	m_appVersion = newAppVersion;
-	emit appVersionChanged(newAppVersion);
 }
+QUuid DeviceInfo::lastUserId() const { return m_lastUserId; }
 
-QString DeviceInfo::lastUserId() const { return m_lastUserId; }
-void DeviceInfo::setLastUserId(QString newLastUserId) {
+void DeviceInfo::setLastUserId(QUuid newLastUserId) {
 	m_lastUserId = newLastUserId;
-	emit lastUserIdChanged(newLastUserId);
 }
-
 QDateTime DeviceInfo::dateLastActivity() const { return m_dateLastActivity; }
+
 void DeviceInfo::setDateLastActivity(QDateTime newDateLastActivity) {
 	m_dateLastActivity = newDateLastActivity;
-	emit dateLastActivityChanged(newDateLastActivity);
 }
+QSharedPointer<ClientCapabilities> DeviceInfo::capabilities() const { return m_capabilities; }
 
-ClientCapabilities * DeviceInfo::capabilities() const { return m_capabilities; }
-void DeviceInfo::setCapabilities(ClientCapabilities * newCapabilities) {
+void DeviceInfo::setCapabilities(QSharedPointer<ClientCapabilities> newCapabilities) {
 	m_capabilities = newCapabilities;
-	emit capabilitiesChanged(newCapabilities);
 }
-
 QString DeviceInfo::iconUrl() const { return m_iconUrl; }
+
 void DeviceInfo::setIconUrl(QString newIconUrl) {
 	m_iconUrl = newIconUrl;
-	emit iconUrlChanged(newIconUrl);
 }
 
 

core/src/DTO/deviceinfoqueryresult.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-DeviceInfoQueryResult::DeviceInfoQueryResult(QObject *parent) : QObject(parent) {}
+DeviceInfoQueryResult::DeviceInfoQueryResult(QObject *parent) {}
 
-DeviceInfoQueryResult *DeviceInfoQueryResult::fromJSON(QJsonObject source, QObject *parent) {
-	DeviceInfoQueryResult *instance = new DeviceInfoQueryResult(parent);
-	instance->updateFromJSON(source);
+DeviceInfoQueryResult DeviceInfoQueryResult::fromJson(QJsonObject source) {DeviceInfoQueryResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DeviceInfoQueryResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DeviceInfoQueryResult::setFromJson(QJsonObject source) {
+	m_items = fromJsonValue<QList<QSharedPointer<DeviceInfo>>>(source["Items"]);
+	m_totalRecordCount = fromJsonValue<qint32>(source["TotalRecordCount"]);
+	m_startIndex = fromJsonValue<qint32>(source["StartIndex"]);
+
 }
-QJsonObject DeviceInfoQueryResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DeviceInfoQueryResult::toJson() {
 	QJsonObject result;
+	result["Items"] = toJsonValue<QList<QSharedPointer<DeviceInfo>>>(m_items);
+	result["TotalRecordCount"] = toJsonValue<qint32>(m_totalRecordCount);
+	result["StartIndex"] = toJsonValue<qint32>(m_startIndex);
+
 	return result;
 }
-QList<DeviceInfo *> DeviceInfoQueryResult::items() const { return m_items; }
-void DeviceInfoQueryResult::setItems(QList<DeviceInfo *> newItems) {
-	m_items = newItems;
-	emit itemsChanged(newItems);
-}
 
+QList<QSharedPointer<DeviceInfo>> DeviceInfoQueryResult::items() const { return m_items; }
+
+void DeviceInfoQueryResult::setItems(QList<QSharedPointer<DeviceInfo>> newItems) {
+	m_items = newItems;
+}
 qint32 DeviceInfoQueryResult::totalRecordCount() const { return m_totalRecordCount; }
+
 void DeviceInfoQueryResult::setTotalRecordCount(qint32 newTotalRecordCount) {
 	m_totalRecordCount = newTotalRecordCount;
-	emit totalRecordCountChanged(newTotalRecordCount);
 }
-
 qint32 DeviceInfoQueryResult::startIndex() const { return m_startIndex; }
+
 void DeviceInfoQueryResult::setStartIndex(qint32 newStartIndex) {
 	m_startIndex = newStartIndex;
-	emit startIndexChanged(newStartIndex);
 }
 
 

core/src/DTO/deviceoptions.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-DeviceOptions::DeviceOptions(QObject *parent) : QObject(parent) {}
+DeviceOptions::DeviceOptions(QObject *parent) {}
 
-DeviceOptions *DeviceOptions::fromJSON(QJsonObject source, QObject *parent) {
-	DeviceOptions *instance = new DeviceOptions(parent);
-	instance->updateFromJSON(source);
+DeviceOptions DeviceOptions::fromJson(QJsonObject source) {DeviceOptions instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DeviceOptions::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DeviceOptions::setFromJson(QJsonObject source) {
+	m_customName = fromJsonValue<QString>(source["CustomName"]);
+
 }
-QJsonObject DeviceOptions::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DeviceOptions::toJson() {
 	QJsonObject result;
+	result["CustomName"] = toJsonValue<QString>(m_customName);
+
 	return result;
 }
+
 QString DeviceOptions::customName() const { return m_customName; }
+
 void DeviceOptions::setCustomName(QString newCustomName) {
 	m_customName = newCustomName;
-	emit customNameChanged(newCustomName);
 }
 
 

core/src/DTO/deviceprofile.cpp

@@ -32,254 +32,296 @@
 namespace Jellyfin {
 namespace DTO {
 
-DeviceProfile::DeviceProfile(QObject *parent) : QObject(parent) {}
+DeviceProfile::DeviceProfile(QObject *parent) {}
 
-DeviceProfile *DeviceProfile::fromJSON(QJsonObject source, QObject *parent) {
-	DeviceProfile *instance = new DeviceProfile(parent);
-	instance->updateFromJSON(source);
+DeviceProfile DeviceProfile::fromJson(QJsonObject source) {DeviceProfile instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DeviceProfile::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DeviceProfile::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_identification = fromJsonValue<QSharedPointer<DeviceIdentification>>(source["Identification"]);
+	m_friendlyName = fromJsonValue<QString>(source["FriendlyName"]);
+	m_manufacturer = fromJsonValue<QString>(source["Manufacturer"]);
+	m_manufacturerUrl = fromJsonValue<QString>(source["ManufacturerUrl"]);
+	m_modelName = fromJsonValue<QString>(source["ModelName"]);
+	m_modelDescription = fromJsonValue<QString>(source["ModelDescription"]);
+	m_modelNumber = fromJsonValue<QString>(source["ModelNumber"]);
+	m_modelUrl = fromJsonValue<QString>(source["ModelUrl"]);
+	m_serialNumber = fromJsonValue<QString>(source["SerialNumber"]);
+	m_enableAlbumArtInDidl = fromJsonValue<bool>(source["EnableAlbumArtInDidl"]);
+	m_enableSingleAlbumArtLimit = fromJsonValue<bool>(source["EnableSingleAlbumArtLimit"]);
+	m_enableSingleSubtitleLimit = fromJsonValue<bool>(source["EnableSingleSubtitleLimit"]);
+	m_supportedMediaTypes = fromJsonValue<QString>(source["SupportedMediaTypes"]);
+	m_userId = fromJsonValue<QString>(source["UserId"]);
+	m_albumArtPn = fromJsonValue<QString>(source["AlbumArtPn"]);
+	m_maxAlbumArtWidth = fromJsonValue<qint32>(source["MaxAlbumArtWidth"]);
+	m_maxAlbumArtHeight = fromJsonValue<qint32>(source["MaxAlbumArtHeight"]);
+	m_maxIconWidth = fromJsonValue<qint32>(source["MaxIconWidth"]);
+	m_maxIconHeight = fromJsonValue<qint32>(source["MaxIconHeight"]);
+	m_maxStreamingBitrate = fromJsonValue<qint32>(source["MaxStreamingBitrate"]);
+	m_maxStaticBitrate = fromJsonValue<qint32>(source["MaxStaticBitrate"]);
+	m_musicStreamingTranscodingBitrate = fromJsonValue<qint32>(source["MusicStreamingTranscodingBitrate"]);
+	m_maxStaticMusicBitrate = fromJsonValue<qint32>(source["MaxStaticMusicBitrate"]);
+	m_sonyAggregationFlags = fromJsonValue<QString>(source["SonyAggregationFlags"]);
+	m_protocolInfo = fromJsonValue<QString>(source["ProtocolInfo"]);
+	m_timelineOffsetSeconds = fromJsonValue<qint32>(source["TimelineOffsetSeconds"]);
+	m_requiresPlainVideoItems = fromJsonValue<bool>(source["RequiresPlainVideoItems"]);
+	m_requiresPlainFolders = fromJsonValue<bool>(source["RequiresPlainFolders"]);
+	m_enableMSMediaReceiverRegistrar = fromJsonValue<bool>(source["EnableMSMediaReceiverRegistrar"]);
+	m_ignoreTranscodeByteRangeRequests = fromJsonValue<bool>(source["IgnoreTranscodeByteRangeRequests"]);
+	m_xmlRootAttributes = fromJsonValue<QList<QSharedPointer<XmlAttribute>>>(source["XmlRootAttributes"]);
+	m_directPlayProfiles = fromJsonValue<QList<QSharedPointer<DirectPlayProfile>>>(source["DirectPlayProfiles"]);
+	m_transcodingProfiles = fromJsonValue<QList<QSharedPointer<TranscodingProfile>>>(source["TranscodingProfiles"]);
+	m_containerProfiles = fromJsonValue<QList<QSharedPointer<ContainerProfile>>>(source["ContainerProfiles"]);
+	m_codecProfiles = fromJsonValue<QList<QSharedPointer<CodecProfile>>>(source["CodecProfiles"]);
+	m_responseProfiles = fromJsonValue<QList<QSharedPointer<ResponseProfile>>>(source["ResponseProfiles"]);
+	m_subtitleProfiles = fromJsonValue<QList<QSharedPointer<SubtitleProfile>>>(source["SubtitleProfiles"]);
+
 }
-QJsonObject DeviceProfile::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DeviceProfile::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["Identification"] = toJsonValue<QSharedPointer<DeviceIdentification>>(m_identification);
+	result["FriendlyName"] = toJsonValue<QString>(m_friendlyName);
+	result["Manufacturer"] = toJsonValue<QString>(m_manufacturer);
+	result["ManufacturerUrl"] = toJsonValue<QString>(m_manufacturerUrl);
+	result["ModelName"] = toJsonValue<QString>(m_modelName);
+	result["ModelDescription"] = toJsonValue<QString>(m_modelDescription);
+	result["ModelNumber"] = toJsonValue<QString>(m_modelNumber);
+	result["ModelUrl"] = toJsonValue<QString>(m_modelUrl);
+	result["SerialNumber"] = toJsonValue<QString>(m_serialNumber);
+	result["EnableAlbumArtInDidl"] = toJsonValue<bool>(m_enableAlbumArtInDidl);
+	result["EnableSingleAlbumArtLimit"] = toJsonValue<bool>(m_enableSingleAlbumArtLimit);
+	result["EnableSingleSubtitleLimit"] = toJsonValue<bool>(m_enableSingleSubtitleLimit);
+	result["SupportedMediaTypes"] = toJsonValue<QString>(m_supportedMediaTypes);
+	result["UserId"] = toJsonValue<QString>(m_userId);
+	result["AlbumArtPn"] = toJsonValue<QString>(m_albumArtPn);
+	result["MaxAlbumArtWidth"] = toJsonValue<qint32>(m_maxAlbumArtWidth);
+	result["MaxAlbumArtHeight"] = toJsonValue<qint32>(m_maxAlbumArtHeight);
+	result["MaxIconWidth"] = toJsonValue<qint32>(m_maxIconWidth);
+	result["MaxIconHeight"] = toJsonValue<qint32>(m_maxIconHeight);
+	result["MaxStreamingBitrate"] = toJsonValue<qint32>(m_maxStreamingBitrate);
+	result["MaxStaticBitrate"] = toJsonValue<qint32>(m_maxStaticBitrate);
+	result["MusicStreamingTranscodingBitrate"] = toJsonValue<qint32>(m_musicStreamingTranscodingBitrate);
+	result["MaxStaticMusicBitrate"] = toJsonValue<qint32>(m_maxStaticMusicBitrate);
+	result["SonyAggregationFlags"] = toJsonValue<QString>(m_sonyAggregationFlags);
+	result["ProtocolInfo"] = toJsonValue<QString>(m_protocolInfo);
+	result["TimelineOffsetSeconds"] = toJsonValue<qint32>(m_timelineOffsetSeconds);
+	result["RequiresPlainVideoItems"] = toJsonValue<bool>(m_requiresPlainVideoItems);
+	result["RequiresPlainFolders"] = toJsonValue<bool>(m_requiresPlainFolders);
+	result["EnableMSMediaReceiverRegistrar"] = toJsonValue<bool>(m_enableMSMediaReceiverRegistrar);
+	result["IgnoreTranscodeByteRangeRequests"] = toJsonValue<bool>(m_ignoreTranscodeByteRangeRequests);
+	result["XmlRootAttributes"] = toJsonValue<QList<QSharedPointer<XmlAttribute>>>(m_xmlRootAttributes);
+	result["DirectPlayProfiles"] = toJsonValue<QList<QSharedPointer<DirectPlayProfile>>>(m_directPlayProfiles);
+	result["TranscodingProfiles"] = toJsonValue<QList<QSharedPointer<TranscodingProfile>>>(m_transcodingProfiles);
+	result["ContainerProfiles"] = toJsonValue<QList<QSharedPointer<ContainerProfile>>>(m_containerProfiles);
+	result["CodecProfiles"] = toJsonValue<QList<QSharedPointer<CodecProfile>>>(m_codecProfiles);
+	result["ResponseProfiles"] = toJsonValue<QList<QSharedPointer<ResponseProfile>>>(m_responseProfiles);
+	result["SubtitleProfiles"] = toJsonValue<QList<QSharedPointer<SubtitleProfile>>>(m_subtitleProfiles);
+
 	return result;
 }
+
 QString DeviceProfile::name() const { return m_name; }
+
 void DeviceProfile::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString DeviceProfile::jellyfinId() const { return m_jellyfinId; }
+
 void DeviceProfile::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
+QSharedPointer<DeviceIdentification> DeviceProfile::identification() const { return m_identification; }
 
-DeviceIdentification * DeviceProfile::identification() const { return m_identification; }
-void DeviceProfile::setIdentification(DeviceIdentification * newIdentification) {
+void DeviceProfile::setIdentification(QSharedPointer<DeviceIdentification> newIdentification) {
 	m_identification = newIdentification;
-	emit identificationChanged(newIdentification);
 }
-
 QString DeviceProfile::friendlyName() const { return m_friendlyName; }
+
 void DeviceProfile::setFriendlyName(QString newFriendlyName) {
 	m_friendlyName = newFriendlyName;
-	emit friendlyNameChanged(newFriendlyName);
 }
-
 QString DeviceProfile::manufacturer() const { return m_manufacturer; }
+
 void DeviceProfile::setManufacturer(QString newManufacturer) {
 	m_manufacturer = newManufacturer;
-	emit manufacturerChanged(newManufacturer);
 }
-
 QString DeviceProfile::manufacturerUrl() const { return m_manufacturerUrl; }
+
 void DeviceProfile::setManufacturerUrl(QString newManufacturerUrl) {
 	m_manufacturerUrl = newManufacturerUrl;
-	emit manufacturerUrlChanged(newManufacturerUrl);
 }
-
 QString DeviceProfile::modelName() const { return m_modelName; }
+
 void DeviceProfile::setModelName(QString newModelName) {
 	m_modelName = newModelName;
-	emit modelNameChanged(newModelName);
 }
-
 QString DeviceProfile::modelDescription() const { return m_modelDescription; }
+
 void DeviceProfile::setModelDescription(QString newModelDescription) {
 	m_modelDescription = newModelDescription;
-	emit modelDescriptionChanged(newModelDescription);
 }
-
 QString DeviceProfile::modelNumber() const { return m_modelNumber; }
+
 void DeviceProfile::setModelNumber(QString newModelNumber) {
 	m_modelNumber = newModelNumber;
-	emit modelNumberChanged(newModelNumber);
 }
-
 QString DeviceProfile::modelUrl() const { return m_modelUrl; }
+
 void DeviceProfile::setModelUrl(QString newModelUrl) {
 	m_modelUrl = newModelUrl;
-	emit modelUrlChanged(newModelUrl);
 }
-
 QString DeviceProfile::serialNumber() const { return m_serialNumber; }
+
 void DeviceProfile::setSerialNumber(QString newSerialNumber) {
 	m_serialNumber = newSerialNumber;
-	emit serialNumberChanged(newSerialNumber);
 }
-
 bool DeviceProfile::enableAlbumArtInDidl() const { return m_enableAlbumArtInDidl; }
+
 void DeviceProfile::setEnableAlbumArtInDidl(bool newEnableAlbumArtInDidl) {
 	m_enableAlbumArtInDidl = newEnableAlbumArtInDidl;
-	emit enableAlbumArtInDidlChanged(newEnableAlbumArtInDidl);
 }
-
 bool DeviceProfile::enableSingleAlbumArtLimit() const { return m_enableSingleAlbumArtLimit; }
+
 void DeviceProfile::setEnableSingleAlbumArtLimit(bool newEnableSingleAlbumArtLimit) {
 	m_enableSingleAlbumArtLimit = newEnableSingleAlbumArtLimit;
-	emit enableSingleAlbumArtLimitChanged(newEnableSingleAlbumArtLimit);
 }
-
 bool DeviceProfile::enableSingleSubtitleLimit() const { return m_enableSingleSubtitleLimit; }
+
 void DeviceProfile::setEnableSingleSubtitleLimit(bool newEnableSingleSubtitleLimit) {
 	m_enableSingleSubtitleLimit = newEnableSingleSubtitleLimit;
-	emit enableSingleSubtitleLimitChanged(newEnableSingleSubtitleLimit);
 }
-
 QString DeviceProfile::supportedMediaTypes() const { return m_supportedMediaTypes; }
+
 void DeviceProfile::setSupportedMediaTypes(QString newSupportedMediaTypes) {
 	m_supportedMediaTypes = newSupportedMediaTypes;
-	emit supportedMediaTypesChanged(newSupportedMediaTypes);
 }
-
 QString DeviceProfile::userId() const { return m_userId; }
+
 void DeviceProfile::setUserId(QString newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 QString DeviceProfile::albumArtPn() const { return m_albumArtPn; }
+
 void DeviceProfile::setAlbumArtPn(QString newAlbumArtPn) {
 	m_albumArtPn = newAlbumArtPn;
-	emit albumArtPnChanged(newAlbumArtPn);
 }
-
 qint32 DeviceProfile::maxAlbumArtWidth() const { return m_maxAlbumArtWidth; }
+
 void DeviceProfile::setMaxAlbumArtWidth(qint32 newMaxAlbumArtWidth) {
 	m_maxAlbumArtWidth = newMaxAlbumArtWidth;
-	emit maxAlbumArtWidthChanged(newMaxAlbumArtWidth);
 }
-
 qint32 DeviceProfile::maxAlbumArtHeight() const { return m_maxAlbumArtHeight; }
+
 void DeviceProfile::setMaxAlbumArtHeight(qint32 newMaxAlbumArtHeight) {
 	m_maxAlbumArtHeight = newMaxAlbumArtHeight;
-	emit maxAlbumArtHeightChanged(newMaxAlbumArtHeight);
 }
-
 qint32 DeviceProfile::maxIconWidth() const { return m_maxIconWidth; }
+
 void DeviceProfile::setMaxIconWidth(qint32 newMaxIconWidth) {
 	m_maxIconWidth = newMaxIconWidth;
-	emit maxIconWidthChanged(newMaxIconWidth);
 }
-
 qint32 DeviceProfile::maxIconHeight() const { return m_maxIconHeight; }
+
 void DeviceProfile::setMaxIconHeight(qint32 newMaxIconHeight) {
 	m_maxIconHeight = newMaxIconHeight;
-	emit maxIconHeightChanged(newMaxIconHeight);
 }
-
 qint32 DeviceProfile::maxStreamingBitrate() const { return m_maxStreamingBitrate; }
+
 void DeviceProfile::setMaxStreamingBitrate(qint32 newMaxStreamingBitrate) {
 	m_maxStreamingBitrate = newMaxStreamingBitrate;
-	emit maxStreamingBitrateChanged(newMaxStreamingBitrate);
 }
-
 qint32 DeviceProfile::maxStaticBitrate() const { return m_maxStaticBitrate; }
+
 void DeviceProfile::setMaxStaticBitrate(qint32 newMaxStaticBitrate) {
 	m_maxStaticBitrate = newMaxStaticBitrate;
-	emit maxStaticBitrateChanged(newMaxStaticBitrate);
 }
-
 qint32 DeviceProfile::musicStreamingTranscodingBitrate() const { return m_musicStreamingTranscodingBitrate; }
+
 void DeviceProfile::setMusicStreamingTranscodingBitrate(qint32 newMusicStreamingTranscodingBitrate) {
 	m_musicStreamingTranscodingBitrate = newMusicStreamingTranscodingBitrate;
-	emit musicStreamingTranscodingBitrateChanged(newMusicStreamingTranscodingBitrate);
 }
-
 qint32 DeviceProfile::maxStaticMusicBitrate() const { return m_maxStaticMusicBitrate; }
+
 void DeviceProfile::setMaxStaticMusicBitrate(qint32 newMaxStaticMusicBitrate) {
 	m_maxStaticMusicBitrate = newMaxStaticMusicBitrate;
-	emit maxStaticMusicBitrateChanged(newMaxStaticMusicBitrate);
 }
-
 QString DeviceProfile::sonyAggregationFlags() const { return m_sonyAggregationFlags; }
+
 void DeviceProfile::setSonyAggregationFlags(QString newSonyAggregationFlags) {
 	m_sonyAggregationFlags = newSonyAggregationFlags;
-	emit sonyAggregationFlagsChanged(newSonyAggregationFlags);
 }
-
 QString DeviceProfile::protocolInfo() const { return m_protocolInfo; }
+
 void DeviceProfile::setProtocolInfo(QString newProtocolInfo) {
 	m_protocolInfo = newProtocolInfo;
-	emit protocolInfoChanged(newProtocolInfo);
 }
-
 qint32 DeviceProfile::timelineOffsetSeconds() const { return m_timelineOffsetSeconds; }
+
 void DeviceProfile::setTimelineOffsetSeconds(qint32 newTimelineOffsetSeconds) {
 	m_timelineOffsetSeconds = newTimelineOffsetSeconds;
-	emit timelineOffsetSecondsChanged(newTimelineOffsetSeconds);
 }
-
 bool DeviceProfile::requiresPlainVideoItems() const { return m_requiresPlainVideoItems; }
+
 void DeviceProfile::setRequiresPlainVideoItems(bool newRequiresPlainVideoItems) {
 	m_requiresPlainVideoItems = newRequiresPlainVideoItems;
-	emit requiresPlainVideoItemsChanged(newRequiresPlainVideoItems);
 }
-
 bool DeviceProfile::requiresPlainFolders() const { return m_requiresPlainFolders; }
+
 void DeviceProfile::setRequiresPlainFolders(bool newRequiresPlainFolders) {
 	m_requiresPlainFolders = newRequiresPlainFolders;
-	emit requiresPlainFoldersChanged(newRequiresPlainFolders);
 }
-
 bool DeviceProfile::enableMSMediaReceiverRegistrar() const { return m_enableMSMediaReceiverRegistrar; }
+
 void DeviceProfile::setEnableMSMediaReceiverRegistrar(bool newEnableMSMediaReceiverRegistrar) {
 	m_enableMSMediaReceiverRegistrar = newEnableMSMediaReceiverRegistrar;
-	emit enableMSMediaReceiverRegistrarChanged(newEnableMSMediaReceiverRegistrar);
 }
-
 bool DeviceProfile::ignoreTranscodeByteRangeRequests() const { return m_ignoreTranscodeByteRangeRequests; }
+
 void DeviceProfile::setIgnoreTranscodeByteRangeRequests(bool newIgnoreTranscodeByteRangeRequests) {
 	m_ignoreTranscodeByteRangeRequests = newIgnoreTranscodeByteRangeRequests;
-	emit ignoreTranscodeByteRangeRequestsChanged(newIgnoreTranscodeByteRangeRequests);
 }
+QList<QSharedPointer<XmlAttribute>> DeviceProfile::xmlRootAttributes() const { return m_xmlRootAttributes; }
 
-QList<XmlAttribute *> DeviceProfile::xmlRootAttributes() const { return m_xmlRootAttributes; }
-void DeviceProfile::setXmlRootAttributes(QList<XmlAttribute *> newXmlRootAttributes) {
+void DeviceProfile::setXmlRootAttributes(QList<QSharedPointer<XmlAttribute>> newXmlRootAttributes) {
 	m_xmlRootAttributes = newXmlRootAttributes;
-	emit xmlRootAttributesChanged(newXmlRootAttributes);
 }
+QList<QSharedPointer<DirectPlayProfile>> DeviceProfile::directPlayProfiles() const { return m_directPlayProfiles; }
 
-QList<DirectPlayProfile *> DeviceProfile::directPlayProfiles() const { return m_directPlayProfiles; }
-void DeviceProfile::setDirectPlayProfiles(QList<DirectPlayProfile *> newDirectPlayProfiles) {
+void DeviceProfile::setDirectPlayProfiles(QList<QSharedPointer<DirectPlayProfile>> newDirectPlayProfiles) {
 	m_directPlayProfiles = newDirectPlayProfiles;
-	emit directPlayProfilesChanged(newDirectPlayProfiles);
 }
+QList<QSharedPointer<TranscodingProfile>> DeviceProfile::transcodingProfiles() const { return m_transcodingProfiles; }
 
-QList<TranscodingProfile *> DeviceProfile::transcodingProfiles() const { return m_transcodingProfiles; }
-void DeviceProfile::setTranscodingProfiles(QList<TranscodingProfile *> newTranscodingProfiles) {
+void DeviceProfile::setTranscodingProfiles(QList<QSharedPointer<TranscodingProfile>> newTranscodingProfiles) {
 	m_transcodingProfiles = newTranscodingProfiles;
-	emit transcodingProfilesChanged(newTranscodingProfiles);
 }
+QList<QSharedPointer<ContainerProfile>> DeviceProfile::containerProfiles() const { return m_containerProfiles; }
 
-QList<ContainerProfile *> DeviceProfile::containerProfiles() const { return m_containerProfiles; }
-void DeviceProfile::setContainerProfiles(QList<ContainerProfile *> newContainerProfiles) {
+void DeviceProfile::setContainerProfiles(QList<QSharedPointer<ContainerProfile>> newContainerProfiles) {
 	m_containerProfiles = newContainerProfiles;
-	emit containerProfilesChanged(newContainerProfiles);
 }
+QList<QSharedPointer<CodecProfile>> DeviceProfile::codecProfiles() const { return m_codecProfiles; }
 
-QList<CodecProfile *> DeviceProfile::codecProfiles() const { return m_codecProfiles; }
-void DeviceProfile::setCodecProfiles(QList<CodecProfile *> newCodecProfiles) {
+void DeviceProfile::setCodecProfiles(QList<QSharedPointer<CodecProfile>> newCodecProfiles) {
 	m_codecProfiles = newCodecProfiles;
-	emit codecProfilesChanged(newCodecProfiles);
 }
+QList<QSharedPointer<ResponseProfile>> DeviceProfile::responseProfiles() const { return m_responseProfiles; }
 
-QList<ResponseProfile *> DeviceProfile::responseProfiles() const { return m_responseProfiles; }
-void DeviceProfile::setResponseProfiles(QList<ResponseProfile *> newResponseProfiles) {
+void DeviceProfile::setResponseProfiles(QList<QSharedPointer<ResponseProfile>> newResponseProfiles) {
 	m_responseProfiles = newResponseProfiles;
-	emit responseProfilesChanged(newResponseProfiles);
 }
+QList<QSharedPointer<SubtitleProfile>> DeviceProfile::subtitleProfiles() const { return m_subtitleProfiles; }
 
-QList<SubtitleProfile *> DeviceProfile::subtitleProfiles() const { return m_subtitleProfiles; }
-void DeviceProfile::setSubtitleProfiles(QList<SubtitleProfile *> newSubtitleProfiles) {
+void DeviceProfile::setSubtitleProfiles(QList<QSharedPointer<SubtitleProfile>> newSubtitleProfiles) {
 	m_subtitleProfiles = newSubtitleProfiles;
-	emit subtitleProfilesChanged(newSubtitleProfiles);
 }
 
 

core/src/DTO/deviceprofileinfo.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/deviceprofileinfo.h>
 
-#include <JellyfinQt/DTO/deviceprofiletype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-DeviceProfileInfo::DeviceProfileInfo(QObject *parent) : QObject(parent) {}
+DeviceProfileInfo::DeviceProfileInfo(QObject *parent) {}
 
-DeviceProfileInfo *DeviceProfileInfo::fromJSON(QJsonObject source, QObject *parent) {
-	DeviceProfileInfo *instance = new DeviceProfileInfo(parent);
-	instance->updateFromJSON(source);
+DeviceProfileInfo DeviceProfileInfo::fromJson(QJsonObject source) {DeviceProfileInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DeviceProfileInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DeviceProfileInfo::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_type = fromJsonValue<DeviceProfileType>(source["Type"]);
+
 }
-QJsonObject DeviceProfileInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DeviceProfileInfo::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Type"] = toJsonValue<DeviceProfileType>(m_type);
+
 	return result;
 }
+
 QString DeviceProfileInfo::jellyfinId() const { return m_jellyfinId; }
+
 void DeviceProfileInfo::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString DeviceProfileInfo::name() const { return m_name; }
+
 void DeviceProfileInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 DeviceProfileType DeviceProfileInfo::type() const { return m_type; }
+
 void DeviceProfileInfo::setType(DeviceProfileType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
 
 

core/src/DTO/directplayprofile.cpp

@@ -29,49 +29,54 @@
 
 #include <JellyfinQt/DTO/directplayprofile.h>
 
-#include <JellyfinQt/DTO/dlnaprofiletype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-DirectPlayProfile::DirectPlayProfile(QObject *parent) : QObject(parent) {}
+DirectPlayProfile::DirectPlayProfile(QObject *parent) {}
 
-DirectPlayProfile *DirectPlayProfile::fromJSON(QJsonObject source, QObject *parent) {
-	DirectPlayProfile *instance = new DirectPlayProfile(parent);
-	instance->updateFromJSON(source);
+DirectPlayProfile DirectPlayProfile::fromJson(QJsonObject source) {DirectPlayProfile instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DirectPlayProfile::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DirectPlayProfile::setFromJson(QJsonObject source) {
+	m_container = fromJsonValue<QString>(source["Container"]);
+	m_audioCodec = fromJsonValue<QString>(source["AudioCodec"]);
+	m_videoCodec = fromJsonValue<QString>(source["VideoCodec"]);
+	m_type = fromJsonValue<DlnaProfileType>(source["Type"]);
+
 }
-QJsonObject DirectPlayProfile::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DirectPlayProfile::toJson() {
 	QJsonObject result;
+	result["Container"] = toJsonValue<QString>(m_container);
+	result["AudioCodec"] = toJsonValue<QString>(m_audioCodec);
+	result["VideoCodec"] = toJsonValue<QString>(m_videoCodec);
+	result["Type"] = toJsonValue<DlnaProfileType>(m_type);
+
 	return result;
 }
+
 QString DirectPlayProfile::container() const { return m_container; }
+
 void DirectPlayProfile::setContainer(QString newContainer) {
 	m_container = newContainer;
-	emit containerChanged(newContainer);
 }
-
 QString DirectPlayProfile::audioCodec() const { return m_audioCodec; }
+
 void DirectPlayProfile::setAudioCodec(QString newAudioCodec) {
 	m_audioCodec = newAudioCodec;
-	emit audioCodecChanged(newAudioCodec);
 }
-
 QString DirectPlayProfile::videoCodec() const { return m_videoCodec; }
+
 void DirectPlayProfile::setVideoCodec(QString newVideoCodec) {
 	m_videoCodec = newVideoCodec;
-	emit videoCodecChanged(newVideoCodec);
 }
-
 DlnaProfileType DirectPlayProfile::type() const { return m_type; }
+
 void DirectPlayProfile::setType(DlnaProfileType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
 
 

core/src/DTO/displaypreferencesdto.cpp

@@ -29,110 +29,124 @@
 
 #include <JellyfinQt/DTO/displaypreferencesdto.h>
 
-#include <JellyfinQt/DTO/scrolldirection.h>
-#include <JellyfinQt/DTO/sortorder.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-DisplayPreferencesDto::DisplayPreferencesDto(QObject *parent) : QObject(parent) {}
+DisplayPreferencesDto::DisplayPreferencesDto(QObject *parent) {}
 
-DisplayPreferencesDto *DisplayPreferencesDto::fromJSON(QJsonObject source, QObject *parent) {
-	DisplayPreferencesDto *instance = new DisplayPreferencesDto(parent);
-	instance->updateFromJSON(source);
+DisplayPreferencesDto DisplayPreferencesDto::fromJson(QJsonObject source) {DisplayPreferencesDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void DisplayPreferencesDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void DisplayPreferencesDto::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_viewType = fromJsonValue<QString>(source["ViewType"]);
+	m_sortBy = fromJsonValue<QString>(source["SortBy"]);
+	m_indexBy = fromJsonValue<QString>(source["IndexBy"]);
+	m_rememberIndexing = fromJsonValue<bool>(source["RememberIndexing"]);
+	m_primaryImageHeight = fromJsonValue<qint32>(source["PrimaryImageHeight"]);
+	m_primaryImageWidth = fromJsonValue<qint32>(source["PrimaryImageWidth"]);
+	m_customPrefs = fromJsonValue<QJsonObject>(source["CustomPrefs"]);
+	m_scrollDirection = fromJsonValue<ScrollDirection>(source["ScrollDirection"]);
+	m_showBackdrop = fromJsonValue<bool>(source["ShowBackdrop"]);
+	m_rememberSorting = fromJsonValue<bool>(source["RememberSorting"]);
+	m_sortOrder = fromJsonValue<SortOrder>(source["SortOrder"]);
+	m_showSidebar = fromJsonValue<bool>(source["ShowSidebar"]);
+	m_client = fromJsonValue<QString>(source["Client"]);
+
 }
-QJsonObject DisplayPreferencesDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject DisplayPreferencesDto::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["ViewType"] = toJsonValue<QString>(m_viewType);
+	result["SortBy"] = toJsonValue<QString>(m_sortBy);
+	result["IndexBy"] = toJsonValue<QString>(m_indexBy);
+	result["RememberIndexing"] = toJsonValue<bool>(m_rememberIndexing);
+	result["PrimaryImageHeight"] = toJsonValue<qint32>(m_primaryImageHeight);
+	result["PrimaryImageWidth"] = toJsonValue<qint32>(m_primaryImageWidth);
+	result["CustomPrefs"] = toJsonValue<QJsonObject>(m_customPrefs);
+	result["ScrollDirection"] = toJsonValue<ScrollDirection>(m_scrollDirection);
+	result["ShowBackdrop"] = toJsonValue<bool>(m_showBackdrop);
+	result["RememberSorting"] = toJsonValue<bool>(m_rememberSorting);
+	result["SortOrder"] = toJsonValue<SortOrder>(m_sortOrder);
+	result["ShowSidebar"] = toJsonValue<bool>(m_showSidebar);
+	result["Client"] = toJsonValue<QString>(m_client);
+
 	return result;
 }
+
 QString DisplayPreferencesDto::jellyfinId() const { return m_jellyfinId; }
+
 void DisplayPreferencesDto::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString DisplayPreferencesDto::viewType() const { return m_viewType; }
+
 void DisplayPreferencesDto::setViewType(QString newViewType) {
 	m_viewType = newViewType;
-	emit viewTypeChanged(newViewType);
 }
-
 QString DisplayPreferencesDto::sortBy() const { return m_sortBy; }
+
 void DisplayPreferencesDto::setSortBy(QString newSortBy) {
 	m_sortBy = newSortBy;
-	emit sortByChanged(newSortBy);
 }
-
 QString DisplayPreferencesDto::indexBy() const { return m_indexBy; }
+
 void DisplayPreferencesDto::setIndexBy(QString newIndexBy) {
 	m_indexBy = newIndexBy;
-	emit indexByChanged(newIndexBy);
 }
-
 bool DisplayPreferencesDto::rememberIndexing() const { return m_rememberIndexing; }
+
 void DisplayPreferencesDto::setRememberIndexing(bool newRememberIndexing) {
 	m_rememberIndexing = newRememberIndexing;
-	emit rememberIndexingChanged(newRememberIndexing);
 }
-
 qint32 DisplayPreferencesDto::primaryImageHeight() const { return m_primaryImageHeight; }
+
 void DisplayPreferencesDto::setPrimaryImageHeight(qint32 newPrimaryImageHeight) {
 	m_primaryImageHeight = newPrimaryImageHeight;
-	emit primaryImageHeightChanged(newPrimaryImageHeight);
 }
-
 qint32 DisplayPreferencesDto::primaryImageWidth() const { return m_primaryImageWidth; }
+
 void DisplayPreferencesDto::setPrimaryImageWidth(qint32 newPrimaryImageWidth) {
 	m_primaryImageWidth = newPrimaryImageWidth;
-	emit primaryImageWidthChanged(newPrimaryImageWidth);
 }
-
 QJsonObject DisplayPreferencesDto::customPrefs() const { return m_customPrefs; }
+
 void DisplayPreferencesDto::setCustomPrefs(QJsonObject newCustomPrefs) {
 	m_customPrefs = newCustomPrefs;
-	emit customPrefsChanged(newCustomPrefs);
 }
-
 ScrollDirection DisplayPreferencesDto::scrollDirection() const { return m_scrollDirection; }
+
 void DisplayPreferencesDto::setScrollDirection(ScrollDirection newScrollDirection) {
 	m_scrollDirection = newScrollDirection;
-	emit scrollDirectionChanged(newScrollDirection);
 }
-
 bool DisplayPreferencesDto::showBackdrop() const { return m_showBackdrop; }
+
 void DisplayPreferencesDto::setShowBackdrop(bool newShowBackdrop) {
 	m_showBackdrop = newShowBackdrop;
-	emit showBackdropChanged(newShowBackdrop);
 }
-
 bool DisplayPreferencesDto::rememberSorting() const { return m_rememberSorting; }
+
 void DisplayPreferencesDto::setRememberSorting(bool newRememberSorting) {
 	m_rememberSorting = newRememberSorting;
-	emit rememberSortingChanged(newRememberSorting);
 }
-
 SortOrder DisplayPreferencesDto::sortOrder() const { return m_sortOrder; }
+
 void DisplayPreferencesDto::setSortOrder(SortOrder newSortOrder) {
 	m_sortOrder = newSortOrder;
-	emit sortOrderChanged(newSortOrder);
 }
-
 bool DisplayPreferencesDto::showSidebar() const { return m_showSidebar; }
+
 void DisplayPreferencesDto::setShowSidebar(bool newShowSidebar) {
 	m_showSidebar = newShowSidebar;
-	emit showSidebarChanged(newShowSidebar);
 }
-
 QString DisplayPreferencesDto::client() const { return m_client; }
+
 void DisplayPreferencesDto::setClient(QString newClient) {
 	m_client = newClient;
-	emit clientChanged(newClient);
 }
 
 

core/src/DTO/endpointinfo.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-EndPointInfo::EndPointInfo(QObject *parent) : QObject(parent) {}
+EndPointInfo::EndPointInfo(QObject *parent) {}
 
-EndPointInfo *EndPointInfo::fromJSON(QJsonObject source, QObject *parent) {
-	EndPointInfo *instance = new EndPointInfo(parent);
-	instance->updateFromJSON(source);
+EndPointInfo EndPointInfo::fromJson(QJsonObject source) {EndPointInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void EndPointInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void EndPointInfo::setFromJson(QJsonObject source) {
+	m_isLocal = fromJsonValue<bool>(source["IsLocal"]);
+	m_isInNetwork = fromJsonValue<bool>(source["IsInNetwork"]);
+
 }
-QJsonObject EndPointInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject EndPointInfo::toJson() {
 	QJsonObject result;
+	result["IsLocal"] = toJsonValue<bool>(m_isLocal);
+	result["IsInNetwork"] = toJsonValue<bool>(m_isInNetwork);
+
 	return result;
 }
+
 bool EndPointInfo::isLocal() const { return m_isLocal; }
+
 void EndPointInfo::setIsLocal(bool newIsLocal) {
 	m_isLocal = newIsLocal;
-	emit isLocalChanged(newIsLocal);
 }
-
 bool EndPointInfo::isInNetwork() const { return m_isInNetwork; }
+
 void EndPointInfo::setIsInNetwork(bool newIsInNetwork) {
 	m_isInNetwork = newIsInNetwork;
-	emit isInNetworkChanged(newIsInNetwork);
 }
 
 

core/src/DTO/externalidinfo.cpp

@@ -29,49 +29,54 @@
 
 #include <JellyfinQt/DTO/externalidinfo.h>
 
-#include <JellyfinQt/DTO/externalidmediatype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ExternalIdInfo::ExternalIdInfo(QObject *parent) : QObject(parent) {}
+ExternalIdInfo::ExternalIdInfo(QObject *parent) {}
 
-ExternalIdInfo *ExternalIdInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ExternalIdInfo *instance = new ExternalIdInfo(parent);
-	instance->updateFromJSON(source);
+ExternalIdInfo ExternalIdInfo::fromJson(QJsonObject source) {ExternalIdInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ExternalIdInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ExternalIdInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_key = fromJsonValue<QString>(source["Key"]);
+	m_type = fromJsonValue<ExternalIdMediaType>(source["Type"]);
+	m_urlFormatString = fromJsonValue<QString>(source["UrlFormatString"]);
+
 }
-QJsonObject ExternalIdInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ExternalIdInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Key"] = toJsonValue<QString>(m_key);
+	result["Type"] = toJsonValue<ExternalIdMediaType>(m_type);
+	result["UrlFormatString"] = toJsonValue<QString>(m_urlFormatString);
+
 	return result;
 }
+
 QString ExternalIdInfo::name() const { return m_name; }
+
 void ExternalIdInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ExternalIdInfo::key() const { return m_key; }
+
 void ExternalIdInfo::setKey(QString newKey) {
 	m_key = newKey;
-	emit keyChanged(newKey);
 }
-
 ExternalIdMediaType ExternalIdInfo::type() const { return m_type; }
+
 void ExternalIdInfo::setType(ExternalIdMediaType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 QString ExternalIdInfo::urlFormatString() const { return m_urlFormatString; }
+
 void ExternalIdInfo::setUrlFormatString(QString newUrlFormatString) {
 	m_urlFormatString = newUrlFormatString;
-	emit urlFormatStringChanged(newUrlFormatString);
 }
 
 

core/src/DTO/externalurl.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-ExternalUrl::ExternalUrl(QObject *parent) : QObject(parent) {}
+ExternalUrl::ExternalUrl(QObject *parent) {}
 
-ExternalUrl *ExternalUrl::fromJSON(QJsonObject source, QObject *parent) {
-	ExternalUrl *instance = new ExternalUrl(parent);
-	instance->updateFromJSON(source);
+ExternalUrl ExternalUrl::fromJson(QJsonObject source) {ExternalUrl instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ExternalUrl::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ExternalUrl::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_url = fromJsonValue<QString>(source["Url"]);
+
 }
-QJsonObject ExternalUrl::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ExternalUrl::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Url"] = toJsonValue<QString>(m_url);
+
 	return result;
 }
+
 QString ExternalUrl::name() const { return m_name; }
+
 void ExternalUrl::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ExternalUrl::url() const { return m_url; }
+
 void ExternalUrl::setUrl(QString newUrl) {
 	m_url = newUrl;
-	emit urlChanged(newUrl);
 }
 
 

core/src/DTO/filesystementryinfo.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/filesystementryinfo.h>
 
-#include <JellyfinQt/DTO/filesystementrytype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-FileSystemEntryInfo::FileSystemEntryInfo(QObject *parent) : QObject(parent) {}
+FileSystemEntryInfo::FileSystemEntryInfo(QObject *parent) {}
 
-FileSystemEntryInfo *FileSystemEntryInfo::fromJSON(QJsonObject source, QObject *parent) {
-	FileSystemEntryInfo *instance = new FileSystemEntryInfo(parent);
-	instance->updateFromJSON(source);
+FileSystemEntryInfo FileSystemEntryInfo::fromJson(QJsonObject source) {FileSystemEntryInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void FileSystemEntryInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void FileSystemEntryInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_type = fromJsonValue<FileSystemEntryType>(source["Type"]);
+
 }
-QJsonObject FileSystemEntryInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject FileSystemEntryInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["Type"] = toJsonValue<FileSystemEntryType>(m_type);
+
 	return result;
 }
+
 QString FileSystemEntryInfo::name() const { return m_name; }
+
 void FileSystemEntryInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString FileSystemEntryInfo::path() const { return m_path; }
+
 void FileSystemEntryInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 FileSystemEntryType FileSystemEntryInfo::type() const { return m_type; }
+
 void FileSystemEntryInfo::setType(FileSystemEntryType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
 
 

core/src/DTO/fontfile.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-FontFile::FontFile(QObject *parent) : QObject(parent) {}
+FontFile::FontFile(QObject *parent) {}
 
-FontFile *FontFile::fromJSON(QJsonObject source, QObject *parent) {
-	FontFile *instance = new FontFile(parent);
-	instance->updateFromJSON(source);
+FontFile FontFile::fromJson(QJsonObject source) {FontFile instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void FontFile::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void FontFile::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_size = fromJsonValue<qint64>(source["Size"]);
+	m_dateCreated = fromJsonValue<QDateTime>(source["DateCreated"]);
+	m_dateModified = fromJsonValue<QDateTime>(source["DateModified"]);
+
 }
-QJsonObject FontFile::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject FontFile::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Size"] = toJsonValue<qint64>(m_size);
+	result["DateCreated"] = toJsonValue<QDateTime>(m_dateCreated);
+	result["DateModified"] = toJsonValue<QDateTime>(m_dateModified);
+
 	return result;
 }
+
 QString FontFile::name() const { return m_name; }
+
 void FontFile::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 qint64 FontFile::size() const { return m_size; }
+
 void FontFile::setSize(qint64 newSize) {
 	m_size = newSize;
-	emit sizeChanged(newSize);
 }
-
 QDateTime FontFile::dateCreated() const { return m_dateCreated; }
+
 void FontFile::setDateCreated(QDateTime newDateCreated) {
 	m_dateCreated = newDateCreated;
-	emit dateCreatedChanged(newDateCreated);
 }
-
 QDateTime FontFile::dateModified() const { return m_dateModified; }
+
 void FontFile::setDateModified(QDateTime newDateModified) {
 	m_dateModified = newDateModified;
-	emit dateModifiedChanged(newDateModified);
 }
 
 

core/src/DTO/forgotpassworddto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-ForgotPasswordDto::ForgotPasswordDto(QObject *parent) : QObject(parent) {}
+ForgotPasswordDto::ForgotPasswordDto(QObject *parent) {}
 
-ForgotPasswordDto *ForgotPasswordDto::fromJSON(QJsonObject source, QObject *parent) {
-	ForgotPasswordDto *instance = new ForgotPasswordDto(parent);
-	instance->updateFromJSON(source);
+ForgotPasswordDto ForgotPasswordDto::fromJson(QJsonObject source) {ForgotPasswordDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ForgotPasswordDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ForgotPasswordDto::setFromJson(QJsonObject source) {
+	m_enteredUsername = fromJsonValue<QString>(source["EnteredUsername"]);
+
 }
-QJsonObject ForgotPasswordDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ForgotPasswordDto::toJson() {
 	QJsonObject result;
+	result["EnteredUsername"] = toJsonValue<QString>(m_enteredUsername);
+
 	return result;
 }
+
 QString ForgotPasswordDto::enteredUsername() const { return m_enteredUsername; }
+
 void ForgotPasswordDto::setEnteredUsername(QString newEnteredUsername) {
 	m_enteredUsername = newEnteredUsername;
-	emit enteredUsernameChanged(newEnteredUsername);
 }
 
 

core/src/DTO/forgotpasswordresult.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/forgotpasswordresult.h>
 
-#include <JellyfinQt/DTO/forgotpasswordaction.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ForgotPasswordResult::ForgotPasswordResult(QObject *parent) : QObject(parent) {}
+ForgotPasswordResult::ForgotPasswordResult(QObject *parent) {}
 
-ForgotPasswordResult *ForgotPasswordResult::fromJSON(QJsonObject source, QObject *parent) {
-	ForgotPasswordResult *instance = new ForgotPasswordResult(parent);
-	instance->updateFromJSON(source);
+ForgotPasswordResult ForgotPasswordResult::fromJson(QJsonObject source) {ForgotPasswordResult instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ForgotPasswordResult::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ForgotPasswordResult::setFromJson(QJsonObject source) {
+	m_action = fromJsonValue<ForgotPasswordAction>(source["Action"]);
+	m_pinFile = fromJsonValue<QString>(source["PinFile"]);
+	m_pinExpirationDate = fromJsonValue<QDateTime>(source["PinExpirationDate"]);
+
 }
-QJsonObject ForgotPasswordResult::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ForgotPasswordResult::toJson() {
 	QJsonObject result;
+	result["Action"] = toJsonValue<ForgotPasswordAction>(m_action);
+	result["PinFile"] = toJsonValue<QString>(m_pinFile);
+	result["PinExpirationDate"] = toJsonValue<QDateTime>(m_pinExpirationDate);
+
 	return result;
 }
+
 ForgotPasswordAction ForgotPasswordResult::action() const { return m_action; }
+
 void ForgotPasswordResult::setAction(ForgotPasswordAction newAction) {
 	m_action = newAction;
-	emit actionChanged(newAction);
 }
-
 QString ForgotPasswordResult::pinFile() const { return m_pinFile; }
+
 void ForgotPasswordResult::setPinFile(QString newPinFile) {
 	m_pinFile = newPinFile;
-	emit pinFileChanged(newPinFile);
 }
-
 QDateTime ForgotPasswordResult::pinExpirationDate() const { return m_pinExpirationDate; }
+
 void ForgotPasswordResult::setPinExpirationDate(QDateTime newPinExpirationDate) {
 	m_pinExpirationDate = newPinExpirationDate;
-	emit pinExpirationDateChanged(newPinExpirationDate);
 }
 
 

core/src/DTO/generalcommand.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/generalcommand.h>
 
-#include <JellyfinQt/DTO/generalcommandtype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-GeneralCommand::GeneralCommand(QObject *parent) : QObject(parent) {}
+GeneralCommand::GeneralCommand(QObject *parent) {}
 
-GeneralCommand *GeneralCommand::fromJSON(QJsonObject source, QObject *parent) {
-	GeneralCommand *instance = new GeneralCommand(parent);
-	instance->updateFromJSON(source);
+GeneralCommand GeneralCommand::fromJson(QJsonObject source) {GeneralCommand instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void GeneralCommand::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void GeneralCommand::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<GeneralCommandType>(source["Name"]);
+	m_controllingUserId = fromJsonValue<QUuid>(source["ControllingUserId"]);
+	m_arguments = fromJsonValue<QJsonObject>(source["Arguments"]);
+
 }
-QJsonObject GeneralCommand::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject GeneralCommand::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<GeneralCommandType>(m_name);
+	result["ControllingUserId"] = toJsonValue<QUuid>(m_controllingUserId);
+	result["Arguments"] = toJsonValue<QJsonObject>(m_arguments);
+
 	return result;
 }
+
 GeneralCommandType GeneralCommand::name() const { return m_name; }
+
 void GeneralCommand::setName(GeneralCommandType newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
+QUuid GeneralCommand::controllingUserId() const { return m_controllingUserId; }
 
-QString GeneralCommand::controllingUserId() const { return m_controllingUserId; }
-void GeneralCommand::setControllingUserId(QString newControllingUserId) {
+void GeneralCommand::setControllingUserId(QUuid newControllingUserId) {
 	m_controllingUserId = newControllingUserId;
-	emit controllingUserIdChanged(newControllingUserId);
 }
-
 QJsonObject GeneralCommand::arguments() const { return m_arguments; }
+
 void GeneralCommand::setArguments(QJsonObject newArguments) {
 	m_arguments = newArguments;
-	emit argumentsChanged(newArguments);
 }
 
 

core/src/DTO/getprogramsdto.cpp

@@ -29,188 +29,215 @@
 
 #include <JellyfinQt/DTO/getprogramsdto.h>
 
-#include <JellyfinQt/DTO/imagetype.h>
-#include <JellyfinQt/DTO/itemfields.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-GetProgramsDto::GetProgramsDto(QObject *parent) : QObject(parent) {}
+GetProgramsDto::GetProgramsDto(QObject *parent) {}
 
-GetProgramsDto *GetProgramsDto::fromJSON(QJsonObject source, QObject *parent) {
-	GetProgramsDto *instance = new GetProgramsDto(parent);
-	instance->updateFromJSON(source);
+GetProgramsDto GetProgramsDto::fromJson(QJsonObject source) {GetProgramsDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void GetProgramsDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void GetProgramsDto::setFromJson(QJsonObject source) {
+	m_channelIds = fromJsonValue<QList<QUuid>>(source["ChannelIds"]);
+	m_userId = fromJsonValue<QUuid>(source["UserId"]);
+	m_minStartDate = fromJsonValue<QDateTime>(source["MinStartDate"]);
+	m_hasAired = fromJsonValue<bool>(source["HasAired"]);
+	m_isAiring = fromJsonValue<bool>(source["IsAiring"]);
+	m_maxStartDate = fromJsonValue<QDateTime>(source["MaxStartDate"]);
+	m_minEndDate = fromJsonValue<QDateTime>(source["MinEndDate"]);
+	m_maxEndDate = fromJsonValue<QDateTime>(source["MaxEndDate"]);
+	m_isMovie = fromJsonValue<bool>(source["IsMovie"]);
+	m_isSeries = fromJsonValue<bool>(source["IsSeries"]);
+	m_isNews = fromJsonValue<bool>(source["IsNews"]);
+	m_isKids = fromJsonValue<bool>(source["IsKids"]);
+	m_isSports = fromJsonValue<bool>(source["IsSports"]);
+	m_startIndex = fromJsonValue<qint32>(source["StartIndex"]);
+	m_limit = fromJsonValue<qint32>(source["Limit"]);
+	m_sortBy = fromJsonValue<QString>(source["SortBy"]);
+	m_sortOrder = fromJsonValue<QString>(source["SortOrder"]);
+	m_genres = fromJsonValue<QStringList>(source["Genres"]);
+	m_genreIds = fromJsonValue<QList<QUuid>>(source["GenreIds"]);
+	m_enableImages = fromJsonValue<bool>(source["EnableImages"]);
+	m_enableTotalRecordCount = fromJsonValue<bool>(source["EnableTotalRecordCount"]);
+	m_imageTypeLimit = fromJsonValue<qint32>(source["ImageTypeLimit"]);
+	m_enableImageTypes = fromJsonValue<QList<ImageType>>(source["EnableImageTypes"]);
+	m_enableUserData = fromJsonValue<bool>(source["EnableUserData"]);
+	m_seriesTimerId = fromJsonValue<QString>(source["SeriesTimerId"]);
+	m_librarySeriesId = fromJsonValue<QUuid>(source["LibrarySeriesId"]);
+	m_fields = fromJsonValue<QList<ItemFields>>(source["Fields"]);
+
 }
-QJsonObject GetProgramsDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject GetProgramsDto::toJson() {
 	QJsonObject result;
+	result["ChannelIds"] = toJsonValue<QList<QUuid>>(m_channelIds);
+	result["UserId"] = toJsonValue<QUuid>(m_userId);
+	result["MinStartDate"] = toJsonValue<QDateTime>(m_minStartDate);
+	result["HasAired"] = toJsonValue<bool>(m_hasAired);
+	result["IsAiring"] = toJsonValue<bool>(m_isAiring);
+	result["MaxStartDate"] = toJsonValue<QDateTime>(m_maxStartDate);
+	result["MinEndDate"] = toJsonValue<QDateTime>(m_minEndDate);
+	result["MaxEndDate"] = toJsonValue<QDateTime>(m_maxEndDate);
+	result["IsMovie"] = toJsonValue<bool>(m_isMovie);
+	result["IsSeries"] = toJsonValue<bool>(m_isSeries);
+	result["IsNews"] = toJsonValue<bool>(m_isNews);
+	result["IsKids"] = toJsonValue<bool>(m_isKids);
+	result["IsSports"] = toJsonValue<bool>(m_isSports);
+	result["StartIndex"] = toJsonValue<qint32>(m_startIndex);
+	result["Limit"] = toJsonValue<qint32>(m_limit);
+	result["SortBy"] = toJsonValue<QString>(m_sortBy);
+	result["SortOrder"] = toJsonValue<QString>(m_sortOrder);
+	result["Genres"] = toJsonValue<QStringList>(m_genres);
+	result["GenreIds"] = toJsonValue<QList<QUuid>>(m_genreIds);
+	result["EnableImages"] = toJsonValue<bool>(m_enableImages);
+	result["EnableTotalRecordCount"] = toJsonValue<bool>(m_enableTotalRecordCount);
+	result["ImageTypeLimit"] = toJsonValue<qint32>(m_imageTypeLimit);
+	result["EnableImageTypes"] = toJsonValue<QList<ImageType>>(m_enableImageTypes);
+	result["EnableUserData"] = toJsonValue<bool>(m_enableUserData);
+	result["SeriesTimerId"] = toJsonValue<QString>(m_seriesTimerId);
+	result["LibrarySeriesId"] = toJsonValue<QUuid>(m_librarySeriesId);
+	result["Fields"] = toJsonValue<QList<ItemFields>>(m_fields);
+
 	return result;
 }
-QStringList GetProgramsDto::channelIds() const { return m_channelIds; }
-void GetProgramsDto::setChannelIds(QStringList newChannelIds) {
+
+QList<QUuid> GetProgramsDto::channelIds() const { return m_channelIds; }
+
+void GetProgramsDto::setChannelIds(QList<QUuid> newChannelIds) {
 	m_channelIds = newChannelIds;
-	emit channelIdsChanged(newChannelIds);
 }
+QUuid GetProgramsDto::userId() const { return m_userId; }
 
-QString GetProgramsDto::userId() const { return m_userId; }
-void GetProgramsDto::setUserId(QString newUserId) {
+void GetProgramsDto::setUserId(QUuid newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 QDateTime GetProgramsDto::minStartDate() const { return m_minStartDate; }
+
 void GetProgramsDto::setMinStartDate(QDateTime newMinStartDate) {
 	m_minStartDate = newMinStartDate;
-	emit minStartDateChanged(newMinStartDate);
 }
-
 bool GetProgramsDto::hasAired() const { return m_hasAired; }
+
 void GetProgramsDto::setHasAired(bool newHasAired) {
 	m_hasAired = newHasAired;
-	emit hasAiredChanged(newHasAired);
 }
-
 bool GetProgramsDto::isAiring() const { return m_isAiring; }
+
 void GetProgramsDto::setIsAiring(bool newIsAiring) {
 	m_isAiring = newIsAiring;
-	emit isAiringChanged(newIsAiring);
 }
-
 QDateTime GetProgramsDto::maxStartDate() const { return m_maxStartDate; }
+
 void GetProgramsDto::setMaxStartDate(QDateTime newMaxStartDate) {
 	m_maxStartDate = newMaxStartDate;
-	emit maxStartDateChanged(newMaxStartDate);
 }
-
 QDateTime GetProgramsDto::minEndDate() const { return m_minEndDate; }
+
 void GetProgramsDto::setMinEndDate(QDateTime newMinEndDate) {
 	m_minEndDate = newMinEndDate;
-	emit minEndDateChanged(newMinEndDate);
 }
-
 QDateTime GetProgramsDto::maxEndDate() const { return m_maxEndDate; }
+
 void GetProgramsDto::setMaxEndDate(QDateTime newMaxEndDate) {
 	m_maxEndDate = newMaxEndDate;
-	emit maxEndDateChanged(newMaxEndDate);
 }
-
 bool GetProgramsDto::isMovie() const { return m_isMovie; }
+
 void GetProgramsDto::setIsMovie(bool newIsMovie) {
 	m_isMovie = newIsMovie;
-	emit isMovieChanged(newIsMovie);
 }
-
 bool GetProgramsDto::isSeries() const { return m_isSeries; }
+
 void GetProgramsDto::setIsSeries(bool newIsSeries) {
 	m_isSeries = newIsSeries;
-	emit isSeriesChanged(newIsSeries);
 }
-
 bool GetProgramsDto::isNews() const { return m_isNews; }
+
 void GetProgramsDto::setIsNews(bool newIsNews) {
 	m_isNews = newIsNews;
-	emit isNewsChanged(newIsNews);
 }
-
 bool GetProgramsDto::isKids() const { return m_isKids; }
+
 void GetProgramsDto::setIsKids(bool newIsKids) {
 	m_isKids = newIsKids;
-	emit isKidsChanged(newIsKids);
 }
-
 bool GetProgramsDto::isSports() const { return m_isSports; }
+
 void GetProgramsDto::setIsSports(bool newIsSports) {
 	m_isSports = newIsSports;
-	emit isSportsChanged(newIsSports);
 }
-
 qint32 GetProgramsDto::startIndex() const { return m_startIndex; }
+
 void GetProgramsDto::setStartIndex(qint32 newStartIndex) {
 	m_startIndex = newStartIndex;
-	emit startIndexChanged(newStartIndex);
 }
-
 qint32 GetProgramsDto::limit() const { return m_limit; }
+
 void GetProgramsDto::setLimit(qint32 newLimit) {
 	m_limit = newLimit;
-	emit limitChanged(newLimit);
 }
-
 QString GetProgramsDto::sortBy() const { return m_sortBy; }
+
 void GetProgramsDto::setSortBy(QString newSortBy) {
 	m_sortBy = newSortBy;
-	emit sortByChanged(newSortBy);
 }
-
 QString GetProgramsDto::sortOrder() const { return m_sortOrder; }
+
 void GetProgramsDto::setSortOrder(QString newSortOrder) {
 	m_sortOrder = newSortOrder;
-	emit sortOrderChanged(newSortOrder);
 }
-
 QStringList GetProgramsDto::genres() const { return m_genres; }
+
 void GetProgramsDto::setGenres(QStringList newGenres) {
 	m_genres = newGenres;
-	emit genresChanged(newGenres);
 }
+QList<QUuid> GetProgramsDto::genreIds() const { return m_genreIds; }
 
-QStringList GetProgramsDto::genreIds() const { return m_genreIds; }
-void GetProgramsDto::setGenreIds(QStringList newGenreIds) {
+void GetProgramsDto::setGenreIds(QList<QUuid> newGenreIds) {
 	m_genreIds = newGenreIds;
-	emit genreIdsChanged(newGenreIds);
 }
-
 bool GetProgramsDto::enableImages() const { return m_enableImages; }
+
 void GetProgramsDto::setEnableImages(bool newEnableImages) {
 	m_enableImages = newEnableImages;
-	emit enableImagesChanged(newEnableImages);
 }
-
 bool GetProgramsDto::enableTotalRecordCount() const { return m_enableTotalRecordCount; }
+
 void GetProgramsDto::setEnableTotalRecordCount(bool newEnableTotalRecordCount) {
 	m_enableTotalRecordCount = newEnableTotalRecordCount;
-	emit enableTotalRecordCountChanged(newEnableTotalRecordCount);
 }
-
 qint32 GetProgramsDto::imageTypeLimit() const { return m_imageTypeLimit; }
+
 void GetProgramsDto::setImageTypeLimit(qint32 newImageTypeLimit) {
 	m_imageTypeLimit = newImageTypeLimit;
-	emit imageTypeLimitChanged(newImageTypeLimit);
 }
-
 QList<ImageType> GetProgramsDto::enableImageTypes() const { return m_enableImageTypes; }
+
 void GetProgramsDto::setEnableImageTypes(QList<ImageType> newEnableImageTypes) {
 	m_enableImageTypes = newEnableImageTypes;
-	emit enableImageTypesChanged(newEnableImageTypes);
 }
-
 bool GetProgramsDto::enableUserData() const { return m_enableUserData; }
+
 void GetProgramsDto::setEnableUserData(bool newEnableUserData) {
 	m_enableUserData = newEnableUserData;
-	emit enableUserDataChanged(newEnableUserData);
 }
-
 QString GetProgramsDto::seriesTimerId() const { return m_seriesTimerId; }
+
 void GetProgramsDto::setSeriesTimerId(QString newSeriesTimerId) {
 	m_seriesTimerId = newSeriesTimerId;
-	emit seriesTimerIdChanged(newSeriesTimerId);
 }
+QUuid GetProgramsDto::librarySeriesId() const { return m_librarySeriesId; }
 
-QString GetProgramsDto::librarySeriesId() const { return m_librarySeriesId; }
-void GetProgramsDto::setLibrarySeriesId(QString newLibrarySeriesId) {
+void GetProgramsDto::setLibrarySeriesId(QUuid newLibrarySeriesId) {
 	m_librarySeriesId = newLibrarySeriesId;
-	emit librarySeriesIdChanged(newLibrarySeriesId);
 }
-
 QList<ItemFields> GetProgramsDto::fields() const { return m_fields; }
+
 void GetProgramsDto::setFields(QList<ItemFields> newFields) {
 	m_fields = newFields;
-	emit fieldsChanged(newFields);
 }
 
 

core/src/DTO/groupinfodto.cpp

@@ -29,55 +29,61 @@
 
 #include <JellyfinQt/DTO/groupinfodto.h>
 
-#include <JellyfinQt/DTO/groupstatetype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-GroupInfoDto::GroupInfoDto(QObject *parent) : QObject(parent) {}
+GroupInfoDto::GroupInfoDto(QObject *parent) {}
 
-GroupInfoDto *GroupInfoDto::fromJSON(QJsonObject source, QObject *parent) {
-	GroupInfoDto *instance = new GroupInfoDto(parent);
-	instance->updateFromJSON(source);
+GroupInfoDto GroupInfoDto::fromJson(QJsonObject source) {GroupInfoDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void GroupInfoDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void GroupInfoDto::setFromJson(QJsonObject source) {
+	m_groupId = fromJsonValue<QUuid>(source["GroupId"]);
+	m_groupName = fromJsonValue<QString>(source["GroupName"]);
+	m_state = fromJsonValue<GroupStateType>(source["State"]);
+	m_participants = fromJsonValue<QStringList>(source["Participants"]);
+	m_lastUpdatedAt = fromJsonValue<QDateTime>(source["LastUpdatedAt"]);
+
 }
-QJsonObject GroupInfoDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject GroupInfoDto::toJson() {
 	QJsonObject result;
+	result["GroupId"] = toJsonValue<QUuid>(m_groupId);
+	result["GroupName"] = toJsonValue<QString>(m_groupName);
+	result["State"] = toJsonValue<GroupStateType>(m_state);
+	result["Participants"] = toJsonValue<QStringList>(m_participants);
+	result["LastUpdatedAt"] = toJsonValue<QDateTime>(m_lastUpdatedAt);
+
 	return result;
 }
-QString GroupInfoDto::groupId() const { return m_groupId; }
-void GroupInfoDto::setGroupId(QString newGroupId) {
-	m_groupId = newGroupId;
-	emit groupIdChanged(newGroupId);
-}
 
+QUuid GroupInfoDto::groupId() const { return m_groupId; }
+
+void GroupInfoDto::setGroupId(QUuid newGroupId) {
+	m_groupId = newGroupId;
+}
 QString GroupInfoDto::groupName() const { return m_groupName; }
+
 void GroupInfoDto::setGroupName(QString newGroupName) {
 	m_groupName = newGroupName;
-	emit groupNameChanged(newGroupName);
 }
-
 GroupStateType GroupInfoDto::state() const { return m_state; }
+
 void GroupInfoDto::setState(GroupStateType newState) {
 	m_state = newState;
-	emit stateChanged(newState);
 }
-
 QStringList GroupInfoDto::participants() const { return m_participants; }
+
 void GroupInfoDto::setParticipants(QStringList newParticipants) {
 	m_participants = newParticipants;
-	emit participantsChanged(newParticipants);
 }
-
 QDateTime GroupInfoDto::lastUpdatedAt() const { return m_lastUpdatedAt; }
+
 void GroupInfoDto::setLastUpdatedAt(QDateTime newLastUpdatedAt) {
 	m_lastUpdatedAt = newLastUpdatedAt;
-	emit lastUpdatedAtChanged(newLastUpdatedAt);
 }
 
 

core/src/DTO/guideinfo.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-GuideInfo::GuideInfo(QObject *parent) : QObject(parent) {}
+GuideInfo::GuideInfo(QObject *parent) {}
 
-GuideInfo *GuideInfo::fromJSON(QJsonObject source, QObject *parent) {
-	GuideInfo *instance = new GuideInfo(parent);
-	instance->updateFromJSON(source);
+GuideInfo GuideInfo::fromJson(QJsonObject source) {GuideInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void GuideInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void GuideInfo::setFromJson(QJsonObject source) {
+	m_startDate = fromJsonValue<QDateTime>(source["StartDate"]);
+	m_endDate = fromJsonValue<QDateTime>(source["EndDate"]);
+
 }
-QJsonObject GuideInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject GuideInfo::toJson() {
 	QJsonObject result;
+	result["StartDate"] = toJsonValue<QDateTime>(m_startDate);
+	result["EndDate"] = toJsonValue<QDateTime>(m_endDate);
+
 	return result;
 }
+
 QDateTime GuideInfo::startDate() const { return m_startDate; }
+
 void GuideInfo::setStartDate(QDateTime newStartDate) {
 	m_startDate = newStartDate;
-	emit startDateChanged(newStartDate);
 }
-
 QDateTime GuideInfo::endDate() const { return m_endDate; }
+
 void GuideInfo::setEndDate(QDateTime newEndDate) {
 	m_endDate = newEndDate;
-	emit endDateChanged(newEndDate);
 }
 
 

core/src/DTO/httpheaderinfo.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/httpheaderinfo.h>
 
-#include <JellyfinQt/DTO/headermatchtype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-HttpHeaderInfo::HttpHeaderInfo(QObject *parent) : QObject(parent) {}
+HttpHeaderInfo::HttpHeaderInfo(QObject *parent) {}
 
-HttpHeaderInfo *HttpHeaderInfo::fromJSON(QJsonObject source, QObject *parent) {
-	HttpHeaderInfo *instance = new HttpHeaderInfo(parent);
-	instance->updateFromJSON(source);
+HttpHeaderInfo HttpHeaderInfo::fromJson(QJsonObject source) {HttpHeaderInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void HttpHeaderInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void HttpHeaderInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_value = fromJsonValue<QString>(source["Value"]);
+	m_match = fromJsonValue<HeaderMatchType>(source["Match"]);
+
 }
-QJsonObject HttpHeaderInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject HttpHeaderInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Value"] = toJsonValue<QString>(m_value);
+	result["Match"] = toJsonValue<HeaderMatchType>(m_match);
+
 	return result;
 }
+
 QString HttpHeaderInfo::name() const { return m_name; }
+
 void HttpHeaderInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString HttpHeaderInfo::value() const { return m_value; }
+
 void HttpHeaderInfo::setValue(QString newValue) {
 	m_value = newValue;
-	emit valueChanged(newValue);
 }
-
 HeaderMatchType HttpHeaderInfo::match() const { return m_match; }
+
 void HttpHeaderInfo::setMatch(HeaderMatchType newMatch) {
 	m_match = newMatch;
-	emit matchChanged(newMatch);
 }
 
 

core/src/DTO/ignorewaitrequestdto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-IgnoreWaitRequestDto::IgnoreWaitRequestDto(QObject *parent) : QObject(parent) {}
+IgnoreWaitRequestDto::IgnoreWaitRequestDto(QObject *parent) {}
 
-IgnoreWaitRequestDto *IgnoreWaitRequestDto::fromJSON(QJsonObject source, QObject *parent) {
-	IgnoreWaitRequestDto *instance = new IgnoreWaitRequestDto(parent);
-	instance->updateFromJSON(source);
+IgnoreWaitRequestDto IgnoreWaitRequestDto::fromJson(QJsonObject source) {IgnoreWaitRequestDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void IgnoreWaitRequestDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void IgnoreWaitRequestDto::setFromJson(QJsonObject source) {
+	m_ignoreWait = fromJsonValue<bool>(source["IgnoreWait"]);
+
 }
-QJsonObject IgnoreWaitRequestDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject IgnoreWaitRequestDto::toJson() {
 	QJsonObject result;
+	result["IgnoreWait"] = toJsonValue<bool>(m_ignoreWait);
+
 	return result;
 }
+
 bool IgnoreWaitRequestDto::ignoreWait() const { return m_ignoreWait; }
+
 void IgnoreWaitRequestDto::setIgnoreWait(bool newIgnoreWait) {
 	m_ignoreWait = newIgnoreWait;
-	emit ignoreWaitChanged(newIgnoreWait);
 }
 
 

core/src/DTO/imagebynameinfo.cpp

@@ -32,50 +32,58 @@
 namespace Jellyfin {
 namespace DTO {
 
-ImageByNameInfo::ImageByNameInfo(QObject *parent) : QObject(parent) {}
+ImageByNameInfo::ImageByNameInfo(QObject *parent) {}
 
-ImageByNameInfo *ImageByNameInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ImageByNameInfo *instance = new ImageByNameInfo(parent);
-	instance->updateFromJSON(source);
+ImageByNameInfo ImageByNameInfo::fromJson(QJsonObject source) {ImageByNameInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ImageByNameInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ImageByNameInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_theme = fromJsonValue<QString>(source["Theme"]);
+	m_context = fromJsonValue<QString>(source["Context"]);
+	m_fileLength = fromJsonValue<qint64>(source["FileLength"]);
+	m_format = fromJsonValue<QString>(source["Format"]);
+
 }
-QJsonObject ImageByNameInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ImageByNameInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Theme"] = toJsonValue<QString>(m_theme);
+	result["Context"] = toJsonValue<QString>(m_context);
+	result["FileLength"] = toJsonValue<qint64>(m_fileLength);
+	result["Format"] = toJsonValue<QString>(m_format);
+
 	return result;
 }
+
 QString ImageByNameInfo::name() const { return m_name; }
+
 void ImageByNameInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString ImageByNameInfo::theme() const { return m_theme; }
+
 void ImageByNameInfo::setTheme(QString newTheme) {
 	m_theme = newTheme;
-	emit themeChanged(newTheme);
 }
-
 QString ImageByNameInfo::context() const { return m_context; }
+
 void ImageByNameInfo::setContext(QString newContext) {
 	m_context = newContext;
-	emit contextChanged(newContext);
 }
-
 qint64 ImageByNameInfo::fileLength() const { return m_fileLength; }
+
 void ImageByNameInfo::setFileLength(qint64 newFileLength) {
 	m_fileLength = newFileLength;
-	emit fileLengthChanged(newFileLength);
 }
-
 QString ImageByNameInfo::format() const { return m_format; }
+
 void ImageByNameInfo::setFormat(QString newFormat) {
 	m_format = newFormat;
-	emit formatChanged(newFormat);
 }
 
 

core/src/DTO/imageinfo.cpp

@@ -29,73 +29,82 @@
 
 #include <JellyfinQt/DTO/imageinfo.h>
 
-#include <JellyfinQt/DTO/imagetype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ImageInfo::ImageInfo(QObject *parent) : QObject(parent) {}
+ImageInfo::ImageInfo(QObject *parent) {}
 
-ImageInfo *ImageInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ImageInfo *instance = new ImageInfo(parent);
-	instance->updateFromJSON(source);
+ImageInfo ImageInfo::fromJson(QJsonObject source) {ImageInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ImageInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ImageInfo::setFromJson(QJsonObject source) {
+	m_imageType = fromJsonValue<ImageType>(source["ImageType"]);
+	m_imageIndex = fromJsonValue<qint32>(source["ImageIndex"]);
+	m_imageTag = fromJsonValue<QString>(source["ImageTag"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_blurHash = fromJsonValue<QString>(source["BlurHash"]);
+	m_height = fromJsonValue<qint32>(source["Height"]);
+	m_width = fromJsonValue<qint32>(source["Width"]);
+	m_size = fromJsonValue<qint64>(source["Size"]);
+
 }
-QJsonObject ImageInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ImageInfo::toJson() {
 	QJsonObject result;
+	result["ImageType"] = toJsonValue<ImageType>(m_imageType);
+	result["ImageIndex"] = toJsonValue<qint32>(m_imageIndex);
+	result["ImageTag"] = toJsonValue<QString>(m_imageTag);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["BlurHash"] = toJsonValue<QString>(m_blurHash);
+	result["Height"] = toJsonValue<qint32>(m_height);
+	result["Width"] = toJsonValue<qint32>(m_width);
+	result["Size"] = toJsonValue<qint64>(m_size);
+
 	return result;
 }
+
 ImageType ImageInfo::imageType() const { return m_imageType; }
+
 void ImageInfo::setImageType(ImageType newImageType) {
 	m_imageType = newImageType;
-	emit imageTypeChanged(newImageType);
 }
-
 qint32 ImageInfo::imageIndex() const { return m_imageIndex; }
+
 void ImageInfo::setImageIndex(qint32 newImageIndex) {
 	m_imageIndex = newImageIndex;
-	emit imageIndexChanged(newImageIndex);
 }
-
 QString ImageInfo::imageTag() const { return m_imageTag; }
+
 void ImageInfo::setImageTag(QString newImageTag) {
 	m_imageTag = newImageTag;
-	emit imageTagChanged(newImageTag);
 }
-
 QString ImageInfo::path() const { return m_path; }
+
 void ImageInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString ImageInfo::blurHash() const { return m_blurHash; }
+
 void ImageInfo::setBlurHash(QString newBlurHash) {
 	m_blurHash = newBlurHash;
-	emit blurHashChanged(newBlurHash);
 }
-
 qint32 ImageInfo::height() const { return m_height; }
+
 void ImageInfo::setHeight(qint32 newHeight) {
 	m_height = newHeight;
-	emit heightChanged(newHeight);
 }
-
 qint32 ImageInfo::width() const { return m_width; }
+
 void ImageInfo::setWidth(qint32 newWidth) {
 	m_width = newWidth;
-	emit widthChanged(newWidth);
 }
-
 qint64 ImageInfo::size() const { return m_size; }
+
 void ImageInfo::setSize(qint64 newSize) {
 	m_size = newSize;
-	emit sizeChanged(newSize);
 }
 
 

core/src/DTO/imageoption.cpp

@@ -29,43 +29,47 @@
 
 #include <JellyfinQt/DTO/imageoption.h>
 
-#include <JellyfinQt/DTO/imagetype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ImageOption::ImageOption(QObject *parent) : QObject(parent) {}
+ImageOption::ImageOption(QObject *parent) {}
 
-ImageOption *ImageOption::fromJSON(QJsonObject source, QObject *parent) {
-	ImageOption *instance = new ImageOption(parent);
-	instance->updateFromJSON(source);
+ImageOption ImageOption::fromJson(QJsonObject source) {ImageOption instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ImageOption::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ImageOption::setFromJson(QJsonObject source) {
+	m_type = fromJsonValue<ImageType>(source["Type"]);
+	m_limit = fromJsonValue<qint32>(source["Limit"]);
+	m_minWidth = fromJsonValue<qint32>(source["MinWidth"]);
+
 }
-QJsonObject ImageOption::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ImageOption::toJson() {
 	QJsonObject result;
+	result["Type"] = toJsonValue<ImageType>(m_type);
+	result["Limit"] = toJsonValue<qint32>(m_limit);
+	result["MinWidth"] = toJsonValue<qint32>(m_minWidth);
+
 	return result;
 }
+
 ImageType ImageOption::type() const { return m_type; }
+
 void ImageOption::setType(ImageType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 qint32 ImageOption::limit() const { return m_limit; }
+
 void ImageOption::setLimit(qint32 newLimit) {
 	m_limit = newLimit;
-	emit limitChanged(newLimit);
 }
-
 qint32 ImageOption::minWidth() const { return m_minWidth; }
+
 void ImageOption::setMinWidth(qint32 newMinWidth) {
 	m_minWidth = newMinWidth;
-	emit minWidthChanged(newMinWidth);
 }
 
 

core/src/DTO/imageproviderinfo.cpp

@@ -29,37 +29,40 @@
 
 #include <JellyfinQt/DTO/imageproviderinfo.h>
 
-#include <JellyfinQt/DTO/imagetype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-ImageProviderInfo::ImageProviderInfo(QObject *parent) : QObject(parent) {}
+ImageProviderInfo::ImageProviderInfo(QObject *parent) {}
 
-ImageProviderInfo *ImageProviderInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ImageProviderInfo *instance = new ImageProviderInfo(parent);
-	instance->updateFromJSON(source);
+ImageProviderInfo ImageProviderInfo::fromJson(QJsonObject source) {ImageProviderInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ImageProviderInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ImageProviderInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_supportedImages = fromJsonValue<QList<ImageType>>(source["SupportedImages"]);
+
 }
-QJsonObject ImageProviderInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ImageProviderInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["SupportedImages"] = toJsonValue<QList<ImageType>>(m_supportedImages);
+
 	return result;
 }
+
 QString ImageProviderInfo::name() const { return m_name; }
+
 void ImageProviderInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QList<ImageType> ImageProviderInfo::supportedImages() const { return m_supportedImages; }
+
 void ImageProviderInfo::setSupportedImages(QList<ImageType> newSupportedImages) {
 	m_supportedImages = newSupportedImages;
-	emit supportedImagesChanged(newSupportedImages);
 }
 
 

core/src/DTO/installationinfo.cpp

@@ -32,56 +32,65 @@
 namespace Jellyfin {
 namespace DTO {
 
-InstallationInfo::InstallationInfo(QObject *parent) : QObject(parent) {}
+InstallationInfo::InstallationInfo(QObject *parent) {}
 
-InstallationInfo *InstallationInfo::fromJSON(QJsonObject source, QObject *parent) {
-	InstallationInfo *instance = new InstallationInfo(parent);
-	instance->updateFromJSON(source);
+InstallationInfo InstallationInfo::fromJson(QJsonObject source) {InstallationInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void InstallationInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void InstallationInfo::setFromJson(QJsonObject source) {
+	m_guid = fromJsonValue<QUuid>(source["Guid"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_version = fromJsonValue<QSharedPointer<Version>>(source["Version"]);
+	m_changelog = fromJsonValue<QString>(source["Changelog"]);
+	m_sourceUrl = fromJsonValue<QString>(source["SourceUrl"]);
+	m_checksum = fromJsonValue<QString>(source["Checksum"]);
+
 }
-QJsonObject InstallationInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject InstallationInfo::toJson() {
 	QJsonObject result;
+	result["Guid"] = toJsonValue<QUuid>(m_guid);
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Version"] = toJsonValue<QSharedPointer<Version>>(m_version);
+	result["Changelog"] = toJsonValue<QString>(m_changelog);
+	result["SourceUrl"] = toJsonValue<QString>(m_sourceUrl);
+	result["Checksum"] = toJsonValue<QString>(m_checksum);
+
 	return result;
 }
-QString InstallationInfo::guid() const { return m_guid; }
-void InstallationInfo::setGuid(QString newGuid) {
-	m_guid = newGuid;
-	emit guidChanged(newGuid);
-}
 
+QUuid InstallationInfo::guid() const { return m_guid; }
+
+void InstallationInfo::setGuid(QUuid newGuid) {
+	m_guid = newGuid;
+}
 QString InstallationInfo::name() const { return m_name; }
+
 void InstallationInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
+QSharedPointer<Version> InstallationInfo::version() const { return m_version; }
 
-Version * InstallationInfo::version() const { return m_version; }
-void InstallationInfo::setVersion(Version * newVersion) {
+void InstallationInfo::setVersion(QSharedPointer<Version> newVersion) {
 	m_version = newVersion;
-	emit versionChanged(newVersion);
 }
-
 QString InstallationInfo::changelog() const { return m_changelog; }
+
 void InstallationInfo::setChangelog(QString newChangelog) {
 	m_changelog = newChangelog;
-	emit changelogChanged(newChangelog);
 }
-
 QString InstallationInfo::sourceUrl() const { return m_sourceUrl; }
+
 void InstallationInfo::setSourceUrl(QString newSourceUrl) {
 	m_sourceUrl = newSourceUrl;
-	emit sourceUrlChanged(newSourceUrl);
 }
-
 QString InstallationInfo::checksum() const { return m_checksum; }
+
 void InstallationInfo::setChecksum(QString newChecksum) {
 	m_checksum = newChecksum;
-	emit checksumChanged(newChecksum);
 }
 
 

core/src/DTO/iplugin.cpp

@@ -32,62 +32,72 @@
 namespace Jellyfin {
 namespace DTO {
 
-IPlugin::IPlugin(QObject *parent) : QObject(parent) {}
+IPlugin::IPlugin(QObject *parent) {}
 
-IPlugin *IPlugin::fromJSON(QJsonObject source, QObject *parent) {
-	IPlugin *instance = new IPlugin(parent);
-	instance->updateFromJSON(source);
+IPlugin IPlugin::fromJson(QJsonObject source) {IPlugin instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void IPlugin::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void IPlugin::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_description = fromJsonValue<QString>(source["Description"]);
+	m_jellyfinId = fromJsonValue<QUuid>(source["Id"]);
+	m_version = fromJsonValue<QSharedPointer<Version>>(source["Version"]);
+	m_assemblyFilePath = fromJsonValue<QString>(source["AssemblyFilePath"]);
+	m_canUninstall = fromJsonValue<bool>(source["CanUninstall"]);
+	m_dataFolderPath = fromJsonValue<QString>(source["DataFolderPath"]);
+
 }
-QJsonObject IPlugin::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject IPlugin::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Description"] = toJsonValue<QString>(m_description);
+	result["Id"] = toJsonValue<QUuid>(m_jellyfinId);
+	result["Version"] = toJsonValue<QSharedPointer<Version>>(m_version);
+	result["AssemblyFilePath"] = toJsonValue<QString>(m_assemblyFilePath);
+	result["CanUninstall"] = toJsonValue<bool>(m_canUninstall);
+	result["DataFolderPath"] = toJsonValue<QString>(m_dataFolderPath);
+
 	return result;
 }
+
 QString IPlugin::name() const { return m_name; }
+
 void IPlugin::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString IPlugin::description() const { return m_description; }
+
 void IPlugin::setDescription(QString newDescription) {
 	m_description = newDescription;
-	emit descriptionChanged(newDescription);
 }
+QUuid IPlugin::jellyfinId() const { return m_jellyfinId; }
 
-QString IPlugin::jellyfinId() const { return m_jellyfinId; }
-void IPlugin::setJellyfinId(QString newJellyfinId) {
+void IPlugin::setJellyfinId(QUuid newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
+QSharedPointer<Version> IPlugin::version() const { return m_version; }
 
-Version * IPlugin::version() const { return m_version; }
-void IPlugin::setVersion(Version * newVersion) {
+void IPlugin::setVersion(QSharedPointer<Version> newVersion) {
 	m_version = newVersion;
-	emit versionChanged(newVersion);
 }
-
 QString IPlugin::assemblyFilePath() const { return m_assemblyFilePath; }
+
 void IPlugin::setAssemblyFilePath(QString newAssemblyFilePath) {
 	m_assemblyFilePath = newAssemblyFilePath;
-	emit assemblyFilePathChanged(newAssemblyFilePath);
 }
-
 bool IPlugin::canUninstall() const { return m_canUninstall; }
+
 void IPlugin::setCanUninstall(bool newCanUninstall) {
 	m_canUninstall = newCanUninstall;
-	emit canUninstallChanged(newCanUninstall);
 }
-
 QString IPlugin::dataFolderPath() const { return m_dataFolderPath; }
+
 void IPlugin::setDataFolderPath(QString newDataFolderPath) {
 	m_dataFolderPath = newDataFolderPath;
-	emit dataFolderPathChanged(newDataFolderPath);
 }
 
 

core/src/DTO/itemcounts.cpp

@@ -32,92 +32,107 @@
 namespace Jellyfin {
 namespace DTO {
 
-ItemCounts::ItemCounts(QObject *parent) : QObject(parent) {}
+ItemCounts::ItemCounts(QObject *parent) {}
 
-ItemCounts *ItemCounts::fromJSON(QJsonObject source, QObject *parent) {
-	ItemCounts *instance = new ItemCounts(parent);
-	instance->updateFromJSON(source);
+ItemCounts ItemCounts::fromJson(QJsonObject source) {ItemCounts instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ItemCounts::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ItemCounts::setFromJson(QJsonObject source) {
+	m_movieCount = fromJsonValue<qint32>(source["MovieCount"]);
+	m_seriesCount = fromJsonValue<qint32>(source["SeriesCount"]);
+	m_episodeCount = fromJsonValue<qint32>(source["EpisodeCount"]);
+	m_artistCount = fromJsonValue<qint32>(source["ArtistCount"]);
+	m_programCount = fromJsonValue<qint32>(source["ProgramCount"]);
+	m_trailerCount = fromJsonValue<qint32>(source["TrailerCount"]);
+	m_songCount = fromJsonValue<qint32>(source["SongCount"]);
+	m_albumCount = fromJsonValue<qint32>(source["AlbumCount"]);
+	m_musicVideoCount = fromJsonValue<qint32>(source["MusicVideoCount"]);
+	m_boxSetCount = fromJsonValue<qint32>(source["BoxSetCount"]);
+	m_bookCount = fromJsonValue<qint32>(source["BookCount"]);
+	m_itemCount = fromJsonValue<qint32>(source["ItemCount"]);
+
 }
-QJsonObject ItemCounts::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ItemCounts::toJson() {
 	QJsonObject result;
+	result["MovieCount"] = toJsonValue<qint32>(m_movieCount);
+	result["SeriesCount"] = toJsonValue<qint32>(m_seriesCount);
+	result["EpisodeCount"] = toJsonValue<qint32>(m_episodeCount);
+	result["ArtistCount"] = toJsonValue<qint32>(m_artistCount);
+	result["ProgramCount"] = toJsonValue<qint32>(m_programCount);
+	result["TrailerCount"] = toJsonValue<qint32>(m_trailerCount);
+	result["SongCount"] = toJsonValue<qint32>(m_songCount);
+	result["AlbumCount"] = toJsonValue<qint32>(m_albumCount);
+	result["MusicVideoCount"] = toJsonValue<qint32>(m_musicVideoCount);
+	result["BoxSetCount"] = toJsonValue<qint32>(m_boxSetCount);
+	result["BookCount"] = toJsonValue<qint32>(m_bookCount);
+	result["ItemCount"] = toJsonValue<qint32>(m_itemCount);
+
 	return result;
 }
+
 qint32 ItemCounts::movieCount() const { return m_movieCount; }
+
 void ItemCounts::setMovieCount(qint32 newMovieCount) {
 	m_movieCount = newMovieCount;
-	emit movieCountChanged(newMovieCount);
 }
-
 qint32 ItemCounts::seriesCount() const { return m_seriesCount; }
+
 void ItemCounts::setSeriesCount(qint32 newSeriesCount) {
 	m_seriesCount = newSeriesCount;
-	emit seriesCountChanged(newSeriesCount);
 }
-
 qint32 ItemCounts::episodeCount() const { return m_episodeCount; }
+
 void ItemCounts::setEpisodeCount(qint32 newEpisodeCount) {
 	m_episodeCount = newEpisodeCount;
-	emit episodeCountChanged(newEpisodeCount);
 }
-
 qint32 ItemCounts::artistCount() const { return m_artistCount; }
+
 void ItemCounts::setArtistCount(qint32 newArtistCount) {
 	m_artistCount = newArtistCount;
-	emit artistCountChanged(newArtistCount);
 }
-
 qint32 ItemCounts::programCount() const { return m_programCount; }
+
 void ItemCounts::setProgramCount(qint32 newProgramCount) {
 	m_programCount = newProgramCount;
-	emit programCountChanged(newProgramCount);
 }
-
 qint32 ItemCounts::trailerCount() const { return m_trailerCount; }
+
 void ItemCounts::setTrailerCount(qint32 newTrailerCount) {
 	m_trailerCount = newTrailerCount;
-	emit trailerCountChanged(newTrailerCount);
 }
-
 qint32 ItemCounts::songCount() const { return m_songCount; }
+
 void ItemCounts::setSongCount(qint32 newSongCount) {
 	m_songCount = newSongCount;
-	emit songCountChanged(newSongCount);
 }
-
 qint32 ItemCounts::albumCount() const { return m_albumCount; }
+
 void ItemCounts::setAlbumCount(qint32 newAlbumCount) {
 	m_albumCount = newAlbumCount;
-	emit albumCountChanged(newAlbumCount);
 }
-
 qint32 ItemCounts::musicVideoCount() const { return m_musicVideoCount; }
+
 void ItemCounts::setMusicVideoCount(qint32 newMusicVideoCount) {
 	m_musicVideoCount = newMusicVideoCount;
-	emit musicVideoCountChanged(newMusicVideoCount);
 }
-
 qint32 ItemCounts::boxSetCount() const { return m_boxSetCount; }
+
 void ItemCounts::setBoxSetCount(qint32 newBoxSetCount) {
 	m_boxSetCount = newBoxSetCount;
-	emit boxSetCountChanged(newBoxSetCount);
 }
-
 qint32 ItemCounts::bookCount() const { return m_bookCount; }
+
 void ItemCounts::setBookCount(qint32 newBookCount) {
 	m_bookCount = newBookCount;
-	emit bookCountChanged(newBookCount);
 }
-
 qint32 ItemCounts::itemCount() const { return m_itemCount; }
+
 void ItemCounts::setItemCount(qint32 newItemCount) {
 	m_itemCount = newItemCount;
-	emit itemCountChanged(newItemCount);
 }
 
 

core/src/DTO/joingrouprequestdto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-JoinGroupRequestDto::JoinGroupRequestDto(QObject *parent) : QObject(parent) {}
+JoinGroupRequestDto::JoinGroupRequestDto(QObject *parent) {}
 
-JoinGroupRequestDto *JoinGroupRequestDto::fromJSON(QJsonObject source, QObject *parent) {
-	JoinGroupRequestDto *instance = new JoinGroupRequestDto(parent);
-	instance->updateFromJSON(source);
+JoinGroupRequestDto JoinGroupRequestDto::fromJson(QJsonObject source) {JoinGroupRequestDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void JoinGroupRequestDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void JoinGroupRequestDto::setFromJson(QJsonObject source) {
+	m_groupId = fromJsonValue<QUuid>(source["GroupId"]);
+
 }
-QJsonObject JoinGroupRequestDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject JoinGroupRequestDto::toJson() {
 	QJsonObject result;
+	result["GroupId"] = toJsonValue<QUuid>(m_groupId);
+
 	return result;
 }
-QString JoinGroupRequestDto::groupId() const { return m_groupId; }
-void JoinGroupRequestDto::setGroupId(QString newGroupId) {
+
+QUuid JoinGroupRequestDto::groupId() const { return m_groupId; }
+
+void JoinGroupRequestDto::setGroupId(QUuid newGroupId) {
 	m_groupId = newGroupId;
-	emit groupIdChanged(newGroupId);
 }
 
 

core/src/DTO/libraryoptioninfodto.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-LibraryOptionInfoDto::LibraryOptionInfoDto(QObject *parent) : QObject(parent) {}
+LibraryOptionInfoDto::LibraryOptionInfoDto(QObject *parent) {}
 
-LibraryOptionInfoDto *LibraryOptionInfoDto::fromJSON(QJsonObject source, QObject *parent) {
-	LibraryOptionInfoDto *instance = new LibraryOptionInfoDto(parent);
-	instance->updateFromJSON(source);
+LibraryOptionInfoDto LibraryOptionInfoDto::fromJson(QJsonObject source) {LibraryOptionInfoDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LibraryOptionInfoDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LibraryOptionInfoDto::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_defaultEnabled = fromJsonValue<bool>(source["DefaultEnabled"]);
+
 }
-QJsonObject LibraryOptionInfoDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LibraryOptionInfoDto::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["DefaultEnabled"] = toJsonValue<bool>(m_defaultEnabled);
+
 	return result;
 }
+
 QString LibraryOptionInfoDto::name() const { return m_name; }
+
 void LibraryOptionInfoDto::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 bool LibraryOptionInfoDto::defaultEnabled() const { return m_defaultEnabled; }
+
 void LibraryOptionInfoDto::setDefaultEnabled(bool newDefaultEnabled) {
 	m_defaultEnabled = newDefaultEnabled;
-	emit defaultEnabledChanged(newDefaultEnabled);
 }
 
 

core/src/DTO/libraryoptions.cpp

@@ -32,170 +32,198 @@
 namespace Jellyfin {
 namespace DTO {
 
-LibraryOptions::LibraryOptions(QObject *parent) : QObject(parent) {}
+LibraryOptions::LibraryOptions(QObject *parent) {}
 
-LibraryOptions *LibraryOptions::fromJSON(QJsonObject source, QObject *parent) {
-	LibraryOptions *instance = new LibraryOptions(parent);
-	instance->updateFromJSON(source);
+LibraryOptions LibraryOptions::fromJson(QJsonObject source) {LibraryOptions instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LibraryOptions::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LibraryOptions::setFromJson(QJsonObject source) {
+	m_enablePhotos = fromJsonValue<bool>(source["EnablePhotos"]);
+	m_enableRealtimeMonitor = fromJsonValue<bool>(source["EnableRealtimeMonitor"]);
+	m_enableChapterImageExtraction = fromJsonValue<bool>(source["EnableChapterImageExtraction"]);
+	m_extractChapterImagesDuringLibraryScan = fromJsonValue<bool>(source["ExtractChapterImagesDuringLibraryScan"]);
+	m_pathInfos = fromJsonValue<QList<QSharedPointer<MediaPathInfo>>>(source["PathInfos"]);
+	m_saveLocalMetadata = fromJsonValue<bool>(source["SaveLocalMetadata"]);
+	m_enableInternetProviders = fromJsonValue<bool>(source["EnableInternetProviders"]);
+	m_enableAutomaticSeriesGrouping = fromJsonValue<bool>(source["EnableAutomaticSeriesGrouping"]);
+	m_enableEmbeddedTitles = fromJsonValue<bool>(source["EnableEmbeddedTitles"]);
+	m_enableEmbeddedEpisodeInfos = fromJsonValue<bool>(source["EnableEmbeddedEpisodeInfos"]);
+	m_automaticRefreshIntervalDays = fromJsonValue<qint32>(source["AutomaticRefreshIntervalDays"]);
+	m_preferredMetadataLanguage = fromJsonValue<QString>(source["PreferredMetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_seasonZeroDisplayName = fromJsonValue<QString>(source["SeasonZeroDisplayName"]);
+	m_metadataSavers = fromJsonValue<QStringList>(source["MetadataSavers"]);
+	m_disabledLocalMetadataReaders = fromJsonValue<QStringList>(source["DisabledLocalMetadataReaders"]);
+	m_localMetadataReaderOrder = fromJsonValue<QStringList>(source["LocalMetadataReaderOrder"]);
+	m_disabledSubtitleFetchers = fromJsonValue<QStringList>(source["DisabledSubtitleFetchers"]);
+	m_subtitleFetcherOrder = fromJsonValue<QStringList>(source["SubtitleFetcherOrder"]);
+	m_skipSubtitlesIfEmbeddedSubtitlesPresent = fromJsonValue<bool>(source["SkipSubtitlesIfEmbeddedSubtitlesPresent"]);
+	m_skipSubtitlesIfAudioTrackMatches = fromJsonValue<bool>(source["SkipSubtitlesIfAudioTrackMatches"]);
+	m_subtitleDownloadLanguages = fromJsonValue<QStringList>(source["SubtitleDownloadLanguages"]);
+	m_requirePerfectSubtitleMatch = fromJsonValue<bool>(source["RequirePerfectSubtitleMatch"]);
+	m_saveSubtitlesWithMedia = fromJsonValue<bool>(source["SaveSubtitlesWithMedia"]);
+	m_typeOptions = fromJsonValue<QList<QSharedPointer<TypeOptions>>>(source["TypeOptions"]);
+
 }
-QJsonObject LibraryOptions::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LibraryOptions::toJson() {
 	QJsonObject result;
+	result["EnablePhotos"] = toJsonValue<bool>(m_enablePhotos);
+	result["EnableRealtimeMonitor"] = toJsonValue<bool>(m_enableRealtimeMonitor);
+	result["EnableChapterImageExtraction"] = toJsonValue<bool>(m_enableChapterImageExtraction);
+	result["ExtractChapterImagesDuringLibraryScan"] = toJsonValue<bool>(m_extractChapterImagesDuringLibraryScan);
+	result["PathInfos"] = toJsonValue<QList<QSharedPointer<MediaPathInfo>>>(m_pathInfos);
+	result["SaveLocalMetadata"] = toJsonValue<bool>(m_saveLocalMetadata);
+	result["EnableInternetProviders"] = toJsonValue<bool>(m_enableInternetProviders);
+	result["EnableAutomaticSeriesGrouping"] = toJsonValue<bool>(m_enableAutomaticSeriesGrouping);
+	result["EnableEmbeddedTitles"] = toJsonValue<bool>(m_enableEmbeddedTitles);
+	result["EnableEmbeddedEpisodeInfos"] = toJsonValue<bool>(m_enableEmbeddedEpisodeInfos);
+	result["AutomaticRefreshIntervalDays"] = toJsonValue<qint32>(m_automaticRefreshIntervalDays);
+	result["PreferredMetadataLanguage"] = toJsonValue<QString>(m_preferredMetadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["SeasonZeroDisplayName"] = toJsonValue<QString>(m_seasonZeroDisplayName);
+	result["MetadataSavers"] = toJsonValue<QStringList>(m_metadataSavers);
+	result["DisabledLocalMetadataReaders"] = toJsonValue<QStringList>(m_disabledLocalMetadataReaders);
+	result["LocalMetadataReaderOrder"] = toJsonValue<QStringList>(m_localMetadataReaderOrder);
+	result["DisabledSubtitleFetchers"] = toJsonValue<QStringList>(m_disabledSubtitleFetchers);
+	result["SubtitleFetcherOrder"] = toJsonValue<QStringList>(m_subtitleFetcherOrder);
+	result["SkipSubtitlesIfEmbeddedSubtitlesPresent"] = toJsonValue<bool>(m_skipSubtitlesIfEmbeddedSubtitlesPresent);
+	result["SkipSubtitlesIfAudioTrackMatches"] = toJsonValue<bool>(m_skipSubtitlesIfAudioTrackMatches);
+	result["SubtitleDownloadLanguages"] = toJsonValue<QStringList>(m_subtitleDownloadLanguages);
+	result["RequirePerfectSubtitleMatch"] = toJsonValue<bool>(m_requirePerfectSubtitleMatch);
+	result["SaveSubtitlesWithMedia"] = toJsonValue<bool>(m_saveSubtitlesWithMedia);
+	result["TypeOptions"] = toJsonValue<QList<QSharedPointer<TypeOptions>>>(m_typeOptions);
+
 	return result;
 }
+
 bool LibraryOptions::enablePhotos() const { return m_enablePhotos; }
+
 void LibraryOptions::setEnablePhotos(bool newEnablePhotos) {
 	m_enablePhotos = newEnablePhotos;
-	emit enablePhotosChanged(newEnablePhotos);
 }
-
 bool LibraryOptions::enableRealtimeMonitor() const { return m_enableRealtimeMonitor; }
+
 void LibraryOptions::setEnableRealtimeMonitor(bool newEnableRealtimeMonitor) {
 	m_enableRealtimeMonitor = newEnableRealtimeMonitor;
-	emit enableRealtimeMonitorChanged(newEnableRealtimeMonitor);
 }
-
 bool LibraryOptions::enableChapterImageExtraction() const { return m_enableChapterImageExtraction; }
+
 void LibraryOptions::setEnableChapterImageExtraction(bool newEnableChapterImageExtraction) {
 	m_enableChapterImageExtraction = newEnableChapterImageExtraction;
-	emit enableChapterImageExtractionChanged(newEnableChapterImageExtraction);
 }
-
 bool LibraryOptions::extractChapterImagesDuringLibraryScan() const { return m_extractChapterImagesDuringLibraryScan; }
+
 void LibraryOptions::setExtractChapterImagesDuringLibraryScan(bool newExtractChapterImagesDuringLibraryScan) {
 	m_extractChapterImagesDuringLibraryScan = newExtractChapterImagesDuringLibraryScan;
-	emit extractChapterImagesDuringLibraryScanChanged(newExtractChapterImagesDuringLibraryScan);
 }
+QList<QSharedPointer<MediaPathInfo>> LibraryOptions::pathInfos() const { return m_pathInfos; }
 
-QList<MediaPathInfo *> LibraryOptions::pathInfos() const { return m_pathInfos; }
-void LibraryOptions::setPathInfos(QList<MediaPathInfo *> newPathInfos) {
+void LibraryOptions::setPathInfos(QList<QSharedPointer<MediaPathInfo>> newPathInfos) {
 	m_pathInfos = newPathInfos;
-	emit pathInfosChanged(newPathInfos);
 }
-
 bool LibraryOptions::saveLocalMetadata() const { return m_saveLocalMetadata; }
+
 void LibraryOptions::setSaveLocalMetadata(bool newSaveLocalMetadata) {
 	m_saveLocalMetadata = newSaveLocalMetadata;
-	emit saveLocalMetadataChanged(newSaveLocalMetadata);
 }
-
 bool LibraryOptions::enableInternetProviders() const { return m_enableInternetProviders; }
+
 void LibraryOptions::setEnableInternetProviders(bool newEnableInternetProviders) {
 	m_enableInternetProviders = newEnableInternetProviders;
-	emit enableInternetProvidersChanged(newEnableInternetProviders);
 }
-
 bool LibraryOptions::enableAutomaticSeriesGrouping() const { return m_enableAutomaticSeriesGrouping; }
+
 void LibraryOptions::setEnableAutomaticSeriesGrouping(bool newEnableAutomaticSeriesGrouping) {
 	m_enableAutomaticSeriesGrouping = newEnableAutomaticSeriesGrouping;
-	emit enableAutomaticSeriesGroupingChanged(newEnableAutomaticSeriesGrouping);
 }
-
 bool LibraryOptions::enableEmbeddedTitles() const { return m_enableEmbeddedTitles; }
+
 void LibraryOptions::setEnableEmbeddedTitles(bool newEnableEmbeddedTitles) {
 	m_enableEmbeddedTitles = newEnableEmbeddedTitles;
-	emit enableEmbeddedTitlesChanged(newEnableEmbeddedTitles);
 }
-
 bool LibraryOptions::enableEmbeddedEpisodeInfos() const { return m_enableEmbeddedEpisodeInfos; }
+
 void LibraryOptions::setEnableEmbeddedEpisodeInfos(bool newEnableEmbeddedEpisodeInfos) {
 	m_enableEmbeddedEpisodeInfos = newEnableEmbeddedEpisodeInfos;
-	emit enableEmbeddedEpisodeInfosChanged(newEnableEmbeddedEpisodeInfos);
 }
-
 qint32 LibraryOptions::automaticRefreshIntervalDays() const { return m_automaticRefreshIntervalDays; }
+
 void LibraryOptions::setAutomaticRefreshIntervalDays(qint32 newAutomaticRefreshIntervalDays) {
 	m_automaticRefreshIntervalDays = newAutomaticRefreshIntervalDays;
-	emit automaticRefreshIntervalDaysChanged(newAutomaticRefreshIntervalDays);
 }
-
 QString LibraryOptions::preferredMetadataLanguage() const { return m_preferredMetadataLanguage; }
+
 void LibraryOptions::setPreferredMetadataLanguage(QString newPreferredMetadataLanguage) {
 	m_preferredMetadataLanguage = newPreferredMetadataLanguage;
-	emit preferredMetadataLanguageChanged(newPreferredMetadataLanguage);
 }
-
 QString LibraryOptions::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void LibraryOptions::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QString LibraryOptions::seasonZeroDisplayName() const { return m_seasonZeroDisplayName; }
+
 void LibraryOptions::setSeasonZeroDisplayName(QString newSeasonZeroDisplayName) {
 	m_seasonZeroDisplayName = newSeasonZeroDisplayName;
-	emit seasonZeroDisplayNameChanged(newSeasonZeroDisplayName);
 }
-
 QStringList LibraryOptions::metadataSavers() const { return m_metadataSavers; }
+
 void LibraryOptions::setMetadataSavers(QStringList newMetadataSavers) {
 	m_metadataSavers = newMetadataSavers;
-	emit metadataSaversChanged(newMetadataSavers);
 }
-
 QStringList LibraryOptions::disabledLocalMetadataReaders() const { return m_disabledLocalMetadataReaders; }
+
 void LibraryOptions::setDisabledLocalMetadataReaders(QStringList newDisabledLocalMetadataReaders) {
 	m_disabledLocalMetadataReaders = newDisabledLocalMetadataReaders;
-	emit disabledLocalMetadataReadersChanged(newDisabledLocalMetadataReaders);
 }
-
 QStringList LibraryOptions::localMetadataReaderOrder() const { return m_localMetadataReaderOrder; }
+
 void LibraryOptions::setLocalMetadataReaderOrder(QStringList newLocalMetadataReaderOrder) {
 	m_localMetadataReaderOrder = newLocalMetadataReaderOrder;
-	emit localMetadataReaderOrderChanged(newLocalMetadataReaderOrder);
 }
-
 QStringList LibraryOptions::disabledSubtitleFetchers() const { return m_disabledSubtitleFetchers; }
+
 void LibraryOptions::setDisabledSubtitleFetchers(QStringList newDisabledSubtitleFetchers) {
 	m_disabledSubtitleFetchers = newDisabledSubtitleFetchers;
-	emit disabledSubtitleFetchersChanged(newDisabledSubtitleFetchers);
 }
-
 QStringList LibraryOptions::subtitleFetcherOrder() const { return m_subtitleFetcherOrder; }
+
 void LibraryOptions::setSubtitleFetcherOrder(QStringList newSubtitleFetcherOrder) {
 	m_subtitleFetcherOrder = newSubtitleFetcherOrder;
-	emit subtitleFetcherOrderChanged(newSubtitleFetcherOrder);
 }
-
 bool LibraryOptions::skipSubtitlesIfEmbeddedSubtitlesPresent() const { return m_skipSubtitlesIfEmbeddedSubtitlesPresent; }
+
 void LibraryOptions::setSkipSubtitlesIfEmbeddedSubtitlesPresent(bool newSkipSubtitlesIfEmbeddedSubtitlesPresent) {
 	m_skipSubtitlesIfEmbeddedSubtitlesPresent = newSkipSubtitlesIfEmbeddedSubtitlesPresent;
-	emit skipSubtitlesIfEmbeddedSubtitlesPresentChanged(newSkipSubtitlesIfEmbeddedSubtitlesPresent);
 }
-
 bool LibraryOptions::skipSubtitlesIfAudioTrackMatches() const { return m_skipSubtitlesIfAudioTrackMatches; }
+
 void LibraryOptions::setSkipSubtitlesIfAudioTrackMatches(bool newSkipSubtitlesIfAudioTrackMatches) {
 	m_skipSubtitlesIfAudioTrackMatches = newSkipSubtitlesIfAudioTrackMatches;
-	emit skipSubtitlesIfAudioTrackMatchesChanged(newSkipSubtitlesIfAudioTrackMatches);
 }
-
 QStringList LibraryOptions::subtitleDownloadLanguages() const { return m_subtitleDownloadLanguages; }
+
 void LibraryOptions::setSubtitleDownloadLanguages(QStringList newSubtitleDownloadLanguages) {
 	m_subtitleDownloadLanguages = newSubtitleDownloadLanguages;
-	emit subtitleDownloadLanguagesChanged(newSubtitleDownloadLanguages);
 }
-
 bool LibraryOptions::requirePerfectSubtitleMatch() const { return m_requirePerfectSubtitleMatch; }
+
 void LibraryOptions::setRequirePerfectSubtitleMatch(bool newRequirePerfectSubtitleMatch) {
 	m_requirePerfectSubtitleMatch = newRequirePerfectSubtitleMatch;
-	emit requirePerfectSubtitleMatchChanged(newRequirePerfectSubtitleMatch);
 }
-
 bool LibraryOptions::saveSubtitlesWithMedia() const { return m_saveSubtitlesWithMedia; }
+
 void LibraryOptions::setSaveSubtitlesWithMedia(bool newSaveSubtitlesWithMedia) {
 	m_saveSubtitlesWithMedia = newSaveSubtitlesWithMedia;
-	emit saveSubtitlesWithMediaChanged(newSaveSubtitlesWithMedia);
 }
+QList<QSharedPointer<TypeOptions>> LibraryOptions::typeOptions() const { return m_typeOptions; }
 
-QList<TypeOptions *> LibraryOptions::typeOptions() const { return m_typeOptions; }
-void LibraryOptions::setTypeOptions(QList<TypeOptions *> newTypeOptions) {
+void LibraryOptions::setTypeOptions(QList<QSharedPointer<TypeOptions>> newTypeOptions) {
 	m_typeOptions = newTypeOptions;
-	emit typeOptionsChanged(newTypeOptions);
 }
 
 

core/src/DTO/libraryoptionsresultdto.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-LibraryOptionsResultDto::LibraryOptionsResultDto(QObject *parent) : QObject(parent) {}
+LibraryOptionsResultDto::LibraryOptionsResultDto(QObject *parent) {}
 
-LibraryOptionsResultDto *LibraryOptionsResultDto::fromJSON(QJsonObject source, QObject *parent) {
-	LibraryOptionsResultDto *instance = new LibraryOptionsResultDto(parent);
-	instance->updateFromJSON(source);
+LibraryOptionsResultDto LibraryOptionsResultDto::fromJson(QJsonObject source) {LibraryOptionsResultDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LibraryOptionsResultDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LibraryOptionsResultDto::setFromJson(QJsonObject source) {
+	m_metadataSavers = fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["MetadataSavers"]);
+	m_metadataReaders = fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["MetadataReaders"]);
+	m_subtitleFetchers = fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["SubtitleFetchers"]);
+	m_typeOptions = fromJsonValue<QList<QSharedPointer<LibraryTypeOptionsDto>>>(source["TypeOptions"]);
+
 }
-QJsonObject LibraryOptionsResultDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LibraryOptionsResultDto::toJson() {
 	QJsonObject result;
+	result["MetadataSavers"] = toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_metadataSavers);
+	result["MetadataReaders"] = toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_metadataReaders);
+	result["SubtitleFetchers"] = toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_subtitleFetchers);
+	result["TypeOptions"] = toJsonValue<QList<QSharedPointer<LibraryTypeOptionsDto>>>(m_typeOptions);
+
 	return result;
 }
-QList<LibraryOptionInfoDto *> LibraryOptionsResultDto::metadataSavers() const { return m_metadataSavers; }
-void LibraryOptionsResultDto::setMetadataSavers(QList<LibraryOptionInfoDto *> newMetadataSavers) {
+
+QList<QSharedPointer<LibraryOptionInfoDto>> LibraryOptionsResultDto::metadataSavers() const { return m_metadataSavers; }
+
+void LibraryOptionsResultDto::setMetadataSavers(QList<QSharedPointer<LibraryOptionInfoDto>> newMetadataSavers) {
 	m_metadataSavers = newMetadataSavers;
-	emit metadataSaversChanged(newMetadataSavers);
 }
+QList<QSharedPointer<LibraryOptionInfoDto>> LibraryOptionsResultDto::metadataReaders() const { return m_metadataReaders; }
 
-QList<LibraryOptionInfoDto *> LibraryOptionsResultDto::metadataReaders() const { return m_metadataReaders; }
-void LibraryOptionsResultDto::setMetadataReaders(QList<LibraryOptionInfoDto *> newMetadataReaders) {
+void LibraryOptionsResultDto::setMetadataReaders(QList<QSharedPointer<LibraryOptionInfoDto>> newMetadataReaders) {
 	m_metadataReaders = newMetadataReaders;
-	emit metadataReadersChanged(newMetadataReaders);
 }
+QList<QSharedPointer<LibraryOptionInfoDto>> LibraryOptionsResultDto::subtitleFetchers() const { return m_subtitleFetchers; }
 
-QList<LibraryOptionInfoDto *> LibraryOptionsResultDto::subtitleFetchers() const { return m_subtitleFetchers; }
-void LibraryOptionsResultDto::setSubtitleFetchers(QList<LibraryOptionInfoDto *> newSubtitleFetchers) {
+void LibraryOptionsResultDto::setSubtitleFetchers(QList<QSharedPointer<LibraryOptionInfoDto>> newSubtitleFetchers) {
 	m_subtitleFetchers = newSubtitleFetchers;
-	emit subtitleFetchersChanged(newSubtitleFetchers);
 }
+QList<QSharedPointer<LibraryTypeOptionsDto>> LibraryOptionsResultDto::typeOptions() const { return m_typeOptions; }
 
-QList<LibraryTypeOptionsDto *> LibraryOptionsResultDto::typeOptions() const { return m_typeOptions; }
-void LibraryOptionsResultDto::setTypeOptions(QList<LibraryTypeOptionsDto *> newTypeOptions) {
+void LibraryOptionsResultDto::setTypeOptions(QList<QSharedPointer<LibraryTypeOptionsDto>> newTypeOptions) {
 	m_typeOptions = newTypeOptions;
-	emit typeOptionsChanged(newTypeOptions);
 }
 
 

core/src/DTO/librarytypeoptionsdto.cpp

@@ -29,55 +29,61 @@
 
 #include <JellyfinQt/DTO/librarytypeoptionsdto.h>
 
-#include <JellyfinQt/DTO/imagetype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-LibraryTypeOptionsDto::LibraryTypeOptionsDto(QObject *parent) : QObject(parent) {}
+LibraryTypeOptionsDto::LibraryTypeOptionsDto(QObject *parent) {}
 
-LibraryTypeOptionsDto *LibraryTypeOptionsDto::fromJSON(QJsonObject source, QObject *parent) {
-	LibraryTypeOptionsDto *instance = new LibraryTypeOptionsDto(parent);
-	instance->updateFromJSON(source);
+LibraryTypeOptionsDto LibraryTypeOptionsDto::fromJson(QJsonObject source) {LibraryTypeOptionsDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LibraryTypeOptionsDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LibraryTypeOptionsDto::setFromJson(QJsonObject source) {
+	m_type = fromJsonValue<QString>(source["Type"]);
+	m_metadataFetchers = fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["MetadataFetchers"]);
+	m_imageFetchers = fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["ImageFetchers"]);
+	m_supportedImageTypes = fromJsonValue<QList<ImageType>>(source["SupportedImageTypes"]);
+	m_defaultImageOptions = fromJsonValue<QList<QSharedPointer<ImageOption>>>(source["DefaultImageOptions"]);
+
 }
-QJsonObject LibraryTypeOptionsDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LibraryTypeOptionsDto::toJson() {
 	QJsonObject result;
+	result["Type"] = toJsonValue<QString>(m_type);
+	result["MetadataFetchers"] = toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_metadataFetchers);
+	result["ImageFetchers"] = toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_imageFetchers);
+	result["SupportedImageTypes"] = toJsonValue<QList<ImageType>>(m_supportedImageTypes);
+	result["DefaultImageOptions"] = toJsonValue<QList<QSharedPointer<ImageOption>>>(m_defaultImageOptions);
+
 	return result;
 }
+
 QString LibraryTypeOptionsDto::type() const { return m_type; }
+
 void LibraryTypeOptionsDto::setType(QString newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
+QList<QSharedPointer<LibraryOptionInfoDto>> LibraryTypeOptionsDto::metadataFetchers() const { return m_metadataFetchers; }
 
-QList<LibraryOptionInfoDto *> LibraryTypeOptionsDto::metadataFetchers() const { return m_metadataFetchers; }
-void LibraryTypeOptionsDto::setMetadataFetchers(QList<LibraryOptionInfoDto *> newMetadataFetchers) {
+void LibraryTypeOptionsDto::setMetadataFetchers(QList<QSharedPointer<LibraryOptionInfoDto>> newMetadataFetchers) {
 	m_metadataFetchers = newMetadataFetchers;
-	emit metadataFetchersChanged(newMetadataFetchers);
 }
+QList<QSharedPointer<LibraryOptionInfoDto>> LibraryTypeOptionsDto::imageFetchers() const { return m_imageFetchers; }
 
-QList<LibraryOptionInfoDto *> LibraryTypeOptionsDto::imageFetchers() const { return m_imageFetchers; }
-void LibraryTypeOptionsDto::setImageFetchers(QList<LibraryOptionInfoDto *> newImageFetchers) {
+void LibraryTypeOptionsDto::setImageFetchers(QList<QSharedPointer<LibraryOptionInfoDto>> newImageFetchers) {
 	m_imageFetchers = newImageFetchers;
-	emit imageFetchersChanged(newImageFetchers);
 }
-
 QList<ImageType> LibraryTypeOptionsDto::supportedImageTypes() const { return m_supportedImageTypes; }
+
 void LibraryTypeOptionsDto::setSupportedImageTypes(QList<ImageType> newSupportedImageTypes) {
 	m_supportedImageTypes = newSupportedImageTypes;
-	emit supportedImageTypesChanged(newSupportedImageTypes);
 }
+QList<QSharedPointer<ImageOption>> LibraryTypeOptionsDto::defaultImageOptions() const { return m_defaultImageOptions; }
 
-QList<ImageOption *> LibraryTypeOptionsDto::defaultImageOptions() const { return m_defaultImageOptions; }
-void LibraryTypeOptionsDto::setDefaultImageOptions(QList<ImageOption *> newDefaultImageOptions) {
+void LibraryTypeOptionsDto::setDefaultImageOptions(QList<QSharedPointer<ImageOption>> newDefaultImageOptions) {
 	m_defaultImageOptions = newDefaultImageOptions;
-	emit defaultImageOptionsChanged(newDefaultImageOptions);
 }
 
 

core/src/DTO/libraryupdateinfo.cpp

@@ -32,62 +32,72 @@
 namespace Jellyfin {
 namespace DTO {
 
-LibraryUpdateInfo::LibraryUpdateInfo(QObject *parent) : QObject(parent) {}
+LibraryUpdateInfo::LibraryUpdateInfo(QObject *parent) {}
 
-LibraryUpdateInfo *LibraryUpdateInfo::fromJSON(QJsonObject source, QObject *parent) {
-	LibraryUpdateInfo *instance = new LibraryUpdateInfo(parent);
-	instance->updateFromJSON(source);
+LibraryUpdateInfo LibraryUpdateInfo::fromJson(QJsonObject source) {LibraryUpdateInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LibraryUpdateInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LibraryUpdateInfo::setFromJson(QJsonObject source) {
+	m_foldersAddedTo = fromJsonValue<QStringList>(source["FoldersAddedTo"]);
+	m_foldersRemovedFrom = fromJsonValue<QStringList>(source["FoldersRemovedFrom"]);
+	m_itemsAdded = fromJsonValue<QStringList>(source["ItemsAdded"]);
+	m_itemsRemoved = fromJsonValue<QStringList>(source["ItemsRemoved"]);
+	m_itemsUpdated = fromJsonValue<QStringList>(source["ItemsUpdated"]);
+	m_collectionFolders = fromJsonValue<QStringList>(source["CollectionFolders"]);
+	m_isEmpty = fromJsonValue<bool>(source["IsEmpty"]);
+
 }
-QJsonObject LibraryUpdateInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LibraryUpdateInfo::toJson() {
 	QJsonObject result;
+	result["FoldersAddedTo"] = toJsonValue<QStringList>(m_foldersAddedTo);
+	result["FoldersRemovedFrom"] = toJsonValue<QStringList>(m_foldersRemovedFrom);
+	result["ItemsAdded"] = toJsonValue<QStringList>(m_itemsAdded);
+	result["ItemsRemoved"] = toJsonValue<QStringList>(m_itemsRemoved);
+	result["ItemsUpdated"] = toJsonValue<QStringList>(m_itemsUpdated);
+	result["CollectionFolders"] = toJsonValue<QStringList>(m_collectionFolders);
+	result["IsEmpty"] = toJsonValue<bool>(m_isEmpty);
+
 	return result;
 }
+
 QStringList LibraryUpdateInfo::foldersAddedTo() const { return m_foldersAddedTo; }
+
 void LibraryUpdateInfo::setFoldersAddedTo(QStringList newFoldersAddedTo) {
 	m_foldersAddedTo = newFoldersAddedTo;
-	emit foldersAddedToChanged(newFoldersAddedTo);
 }
-
 QStringList LibraryUpdateInfo::foldersRemovedFrom() const { return m_foldersRemovedFrom; }
+
 void LibraryUpdateInfo::setFoldersRemovedFrom(QStringList newFoldersRemovedFrom) {
 	m_foldersRemovedFrom = newFoldersRemovedFrom;
-	emit foldersRemovedFromChanged(newFoldersRemovedFrom);
 }
-
 QStringList LibraryUpdateInfo::itemsAdded() const { return m_itemsAdded; }
+
 void LibraryUpdateInfo::setItemsAdded(QStringList newItemsAdded) {
 	m_itemsAdded = newItemsAdded;
-	emit itemsAddedChanged(newItemsAdded);
 }
-
 QStringList LibraryUpdateInfo::itemsRemoved() const { return m_itemsRemoved; }
+
 void LibraryUpdateInfo::setItemsRemoved(QStringList newItemsRemoved) {
 	m_itemsRemoved = newItemsRemoved;
-	emit itemsRemovedChanged(newItemsRemoved);
 }
-
 QStringList LibraryUpdateInfo::itemsUpdated() const { return m_itemsUpdated; }
+
 void LibraryUpdateInfo::setItemsUpdated(QStringList newItemsUpdated) {
 	m_itemsUpdated = newItemsUpdated;
-	emit itemsUpdatedChanged(newItemsUpdated);
 }
-
 QStringList LibraryUpdateInfo::collectionFolders() const { return m_collectionFolders; }
+
 void LibraryUpdateInfo::setCollectionFolders(QStringList newCollectionFolders) {
 	m_collectionFolders = newCollectionFolders;
-	emit collectionFoldersChanged(newCollectionFolders);
 }
-
 bool LibraryUpdateInfo::isEmpty() const { return m_isEmpty; }
+
 void LibraryUpdateInfo::setIsEmpty(bool newIsEmpty) {
 	m_isEmpty = newIsEmpty;
-	emit isEmptyChanged(newIsEmpty);
 }
 
 

core/src/DTO/listingsproviderinfo.cpp

@@ -32,128 +32,149 @@
 namespace Jellyfin {
 namespace DTO {
 
-ListingsProviderInfo::ListingsProviderInfo(QObject *parent) : QObject(parent) {}
+ListingsProviderInfo::ListingsProviderInfo(QObject *parent) {}
 
-ListingsProviderInfo *ListingsProviderInfo::fromJSON(QJsonObject source, QObject *parent) {
-	ListingsProviderInfo *instance = new ListingsProviderInfo(parent);
-	instance->updateFromJSON(source);
+ListingsProviderInfo ListingsProviderInfo::fromJson(QJsonObject source) {ListingsProviderInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void ListingsProviderInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void ListingsProviderInfo::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_type = fromJsonValue<QString>(source["Type"]);
+	m_username = fromJsonValue<QString>(source["Username"]);
+	m_password = fromJsonValue<QString>(source["Password"]);
+	m_listingsId = fromJsonValue<QString>(source["ListingsId"]);
+	m_zipCode = fromJsonValue<QString>(source["ZipCode"]);
+	m_country = fromJsonValue<QString>(source["Country"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_enabledTuners = fromJsonValue<QStringList>(source["EnabledTuners"]);
+	m_enableAllTuners = fromJsonValue<bool>(source["EnableAllTuners"]);
+	m_newsCategories = fromJsonValue<QStringList>(source["NewsCategories"]);
+	m_sportsCategories = fromJsonValue<QStringList>(source["SportsCategories"]);
+	m_kidsCategories = fromJsonValue<QStringList>(source["KidsCategories"]);
+	m_movieCategories = fromJsonValue<QStringList>(source["MovieCategories"]);
+	m_channelMappings = fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["ChannelMappings"]);
+	m_moviePrefix = fromJsonValue<QString>(source["MoviePrefix"]);
+	m_preferredLanguage = fromJsonValue<QString>(source["PreferredLanguage"]);
+	m_userAgent = fromJsonValue<QString>(source["UserAgent"]);
+
 }
-QJsonObject ListingsProviderInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject ListingsProviderInfo::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["Type"] = toJsonValue<QString>(m_type);
+	result["Username"] = toJsonValue<QString>(m_username);
+	result["Password"] = toJsonValue<QString>(m_password);
+	result["ListingsId"] = toJsonValue<QString>(m_listingsId);
+	result["ZipCode"] = toJsonValue<QString>(m_zipCode);
+	result["Country"] = toJsonValue<QString>(m_country);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["EnabledTuners"] = toJsonValue<QStringList>(m_enabledTuners);
+	result["EnableAllTuners"] = toJsonValue<bool>(m_enableAllTuners);
+	result["NewsCategories"] = toJsonValue<QStringList>(m_newsCategories);
+	result["SportsCategories"] = toJsonValue<QStringList>(m_sportsCategories);
+	result["KidsCategories"] = toJsonValue<QStringList>(m_kidsCategories);
+	result["MovieCategories"] = toJsonValue<QStringList>(m_movieCategories);
+	result["ChannelMappings"] = toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_channelMappings);
+	result["MoviePrefix"] = toJsonValue<QString>(m_moviePrefix);
+	result["PreferredLanguage"] = toJsonValue<QString>(m_preferredLanguage);
+	result["UserAgent"] = toJsonValue<QString>(m_userAgent);
+
 	return result;
 }
+
 QString ListingsProviderInfo::jellyfinId() const { return m_jellyfinId; }
+
 void ListingsProviderInfo::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString ListingsProviderInfo::type() const { return m_type; }
+
 void ListingsProviderInfo::setType(QString newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 QString ListingsProviderInfo::username() const { return m_username; }
+
 void ListingsProviderInfo::setUsername(QString newUsername) {
 	m_username = newUsername;
-	emit usernameChanged(newUsername);
 }
-
 QString ListingsProviderInfo::password() const { return m_password; }
+
 void ListingsProviderInfo::setPassword(QString newPassword) {
 	m_password = newPassword;
-	emit passwordChanged(newPassword);
 }
-
 QString ListingsProviderInfo::listingsId() const { return m_listingsId; }
+
 void ListingsProviderInfo::setListingsId(QString newListingsId) {
 	m_listingsId = newListingsId;
-	emit listingsIdChanged(newListingsId);
 }
-
 QString ListingsProviderInfo::zipCode() const { return m_zipCode; }
+
 void ListingsProviderInfo::setZipCode(QString newZipCode) {
 	m_zipCode = newZipCode;
-	emit zipCodeChanged(newZipCode);
 }
-
 QString ListingsProviderInfo::country() const { return m_country; }
+
 void ListingsProviderInfo::setCountry(QString newCountry) {
 	m_country = newCountry;
-	emit countryChanged(newCountry);
 }
-
 QString ListingsProviderInfo::path() const { return m_path; }
+
 void ListingsProviderInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QStringList ListingsProviderInfo::enabledTuners() const { return m_enabledTuners; }
+
 void ListingsProviderInfo::setEnabledTuners(QStringList newEnabledTuners) {
 	m_enabledTuners = newEnabledTuners;
-	emit enabledTunersChanged(newEnabledTuners);
 }
-
 bool ListingsProviderInfo::enableAllTuners() const { return m_enableAllTuners; }
+
 void ListingsProviderInfo::setEnableAllTuners(bool newEnableAllTuners) {
 	m_enableAllTuners = newEnableAllTuners;
-	emit enableAllTunersChanged(newEnableAllTuners);
 }
-
 QStringList ListingsProviderInfo::newsCategories() const { return m_newsCategories; }
+
 void ListingsProviderInfo::setNewsCategories(QStringList newNewsCategories) {
 	m_newsCategories = newNewsCategories;
-	emit newsCategoriesChanged(newNewsCategories);
 }
-
 QStringList ListingsProviderInfo::sportsCategories() const { return m_sportsCategories; }
+
 void ListingsProviderInfo::setSportsCategories(QStringList newSportsCategories) {
 	m_sportsCategories = newSportsCategories;
-	emit sportsCategoriesChanged(newSportsCategories);
 }
-
 QStringList ListingsProviderInfo::kidsCategories() const { return m_kidsCategories; }
+
 void ListingsProviderInfo::setKidsCategories(QStringList newKidsCategories) {
 	m_kidsCategories = newKidsCategories;
-	emit kidsCategoriesChanged(newKidsCategories);
 }
-
 QStringList ListingsProviderInfo::movieCategories() const { return m_movieCategories; }
+
 void ListingsProviderInfo::setMovieCategories(QStringList newMovieCategories) {
 	m_movieCategories = newMovieCategories;
-	emit movieCategoriesChanged(newMovieCategories);
 }
+QList<QSharedPointer<NameValuePair>> ListingsProviderInfo::channelMappings() const { return m_channelMappings; }
 
-QList<NameValuePair *> ListingsProviderInfo::channelMappings() const { return m_channelMappings; }
-void ListingsProviderInfo::setChannelMappings(QList<NameValuePair *> newChannelMappings) {
+void ListingsProviderInfo::setChannelMappings(QList<QSharedPointer<NameValuePair>> newChannelMappings) {
 	m_channelMappings = newChannelMappings;
-	emit channelMappingsChanged(newChannelMappings);
 }
-
 QString ListingsProviderInfo::moviePrefix() const { return m_moviePrefix; }
+
 void ListingsProviderInfo::setMoviePrefix(QString newMoviePrefix) {
 	m_moviePrefix = newMoviePrefix;
-	emit moviePrefixChanged(newMoviePrefix);
 }
-
 QString ListingsProviderInfo::preferredLanguage() const { return m_preferredLanguage; }
+
 void ListingsProviderInfo::setPreferredLanguage(QString newPreferredLanguage) {
 	m_preferredLanguage = newPreferredLanguage;
-	emit preferredLanguageChanged(newPreferredLanguage);
 }
-
 QString ListingsProviderInfo::userAgent() const { return m_userAgent; }
+
 void ListingsProviderInfo::setUserAgent(QString newUserAgent) {
 	m_userAgent = newUserAgent;
-	emit userAgentChanged(newUserAgent);
 }
 
 

core/src/DTO/livestreamresponse.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-LiveStreamResponse::LiveStreamResponse(QObject *parent) : QObject(parent) {}
+LiveStreamResponse::LiveStreamResponse(QObject *parent) {}
 
-LiveStreamResponse *LiveStreamResponse::fromJSON(QJsonObject source, QObject *parent) {
-	LiveStreamResponse *instance = new LiveStreamResponse(parent);
-	instance->updateFromJSON(source);
+LiveStreamResponse LiveStreamResponse::fromJson(QJsonObject source) {LiveStreamResponse instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LiveStreamResponse::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LiveStreamResponse::setFromJson(QJsonObject source) {
+	m_mediaSource = fromJsonValue<QSharedPointer<MediaSourceInfo>>(source["MediaSource"]);
+
 }
-QJsonObject LiveStreamResponse::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LiveStreamResponse::toJson() {
 	QJsonObject result;
+	result["MediaSource"] = toJsonValue<QSharedPointer<MediaSourceInfo>>(m_mediaSource);
+
 	return result;
 }
-MediaSourceInfo * LiveStreamResponse::mediaSource() const { return m_mediaSource; }
-void LiveStreamResponse::setMediaSource(MediaSourceInfo * newMediaSource) {
+
+QSharedPointer<MediaSourceInfo> LiveStreamResponse::mediaSource() const { return m_mediaSource; }
+
+void LiveStreamResponse::setMediaSource(QSharedPointer<MediaSourceInfo> newMediaSource) {
 	m_mediaSource = newMediaSource;
-	emit mediaSourceChanged(newMediaSource);
 }
 
 

core/src/DTO/livetvinfo.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-LiveTvInfo::LiveTvInfo(QObject *parent) : QObject(parent) {}
+LiveTvInfo::LiveTvInfo(QObject *parent) {}
 
-LiveTvInfo *LiveTvInfo::fromJSON(QJsonObject source, QObject *parent) {
-	LiveTvInfo *instance = new LiveTvInfo(parent);
-	instance->updateFromJSON(source);
+LiveTvInfo LiveTvInfo::fromJson(QJsonObject source) {LiveTvInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LiveTvInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LiveTvInfo::setFromJson(QJsonObject source) {
+	m_services = fromJsonValue<QList<QSharedPointer<LiveTvServiceInfo>>>(source["Services"]);
+	m_isEnabled = fromJsonValue<bool>(source["IsEnabled"]);
+	m_enabledUsers = fromJsonValue<QStringList>(source["EnabledUsers"]);
+
 }
-QJsonObject LiveTvInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LiveTvInfo::toJson() {
 	QJsonObject result;
+	result["Services"] = toJsonValue<QList<QSharedPointer<LiveTvServiceInfo>>>(m_services);
+	result["IsEnabled"] = toJsonValue<bool>(m_isEnabled);
+	result["EnabledUsers"] = toJsonValue<QStringList>(m_enabledUsers);
+
 	return result;
 }
-QList<LiveTvServiceInfo *> LiveTvInfo::services() const { return m_services; }
-void LiveTvInfo::setServices(QList<LiveTvServiceInfo *> newServices) {
-	m_services = newServices;
-	emit servicesChanged(newServices);
-}
 
+QList<QSharedPointer<LiveTvServiceInfo>> LiveTvInfo::services() const { return m_services; }
+
+void LiveTvInfo::setServices(QList<QSharedPointer<LiveTvServiceInfo>> newServices) {
+	m_services = newServices;
+}
 bool LiveTvInfo::isEnabled() const { return m_isEnabled; }
+
 void LiveTvInfo::setIsEnabled(bool newIsEnabled) {
 	m_isEnabled = newIsEnabled;
-	emit isEnabledChanged(newIsEnabled);
 }
-
 QStringList LiveTvInfo::enabledUsers() const { return m_enabledUsers; }
+
 void LiveTvInfo::setEnabledUsers(QStringList newEnabledUsers) {
 	m_enabledUsers = newEnabledUsers;
-	emit enabledUsersChanged(newEnabledUsers);
 }
 
 

core/src/DTO/livetvserviceinfo.cpp

@@ -29,73 +29,82 @@
 
 #include <JellyfinQt/DTO/livetvserviceinfo.h>
 
-#include <JellyfinQt/DTO/livetvservicestatus.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-LiveTvServiceInfo::LiveTvServiceInfo(QObject *parent) : QObject(parent) {}
+LiveTvServiceInfo::LiveTvServiceInfo(QObject *parent) {}
 
-LiveTvServiceInfo *LiveTvServiceInfo::fromJSON(QJsonObject source, QObject *parent) {
-	LiveTvServiceInfo *instance = new LiveTvServiceInfo(parent);
-	instance->updateFromJSON(source);
+LiveTvServiceInfo LiveTvServiceInfo::fromJson(QJsonObject source) {LiveTvServiceInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LiveTvServiceInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LiveTvServiceInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_homePageUrl = fromJsonValue<QString>(source["HomePageUrl"]);
+	m_status = fromJsonValue<LiveTvServiceStatus>(source["Status"]);
+	m_statusMessage = fromJsonValue<QString>(source["StatusMessage"]);
+	m_version = fromJsonValue<QString>(source["Version"]);
+	m_hasUpdateAvailable = fromJsonValue<bool>(source["HasUpdateAvailable"]);
+	m_isVisible = fromJsonValue<bool>(source["IsVisible"]);
+	m_tuners = fromJsonValue<QStringList>(source["Tuners"]);
+
 }
-QJsonObject LiveTvServiceInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LiveTvServiceInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["HomePageUrl"] = toJsonValue<QString>(m_homePageUrl);
+	result["Status"] = toJsonValue<LiveTvServiceStatus>(m_status);
+	result["StatusMessage"] = toJsonValue<QString>(m_statusMessage);
+	result["Version"] = toJsonValue<QString>(m_version);
+	result["HasUpdateAvailable"] = toJsonValue<bool>(m_hasUpdateAvailable);
+	result["IsVisible"] = toJsonValue<bool>(m_isVisible);
+	result["Tuners"] = toJsonValue<QStringList>(m_tuners);
+
 	return result;
 }
+
 QString LiveTvServiceInfo::name() const { return m_name; }
+
 void LiveTvServiceInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString LiveTvServiceInfo::homePageUrl() const { return m_homePageUrl; }
+
 void LiveTvServiceInfo::setHomePageUrl(QString newHomePageUrl) {
 	m_homePageUrl = newHomePageUrl;
-	emit homePageUrlChanged(newHomePageUrl);
 }
-
 LiveTvServiceStatus LiveTvServiceInfo::status() const { return m_status; }
+
 void LiveTvServiceInfo::setStatus(LiveTvServiceStatus newStatus) {
 	m_status = newStatus;
-	emit statusChanged(newStatus);
 }
-
 QString LiveTvServiceInfo::statusMessage() const { return m_statusMessage; }
+
 void LiveTvServiceInfo::setStatusMessage(QString newStatusMessage) {
 	m_statusMessage = newStatusMessage;
-	emit statusMessageChanged(newStatusMessage);
 }
-
 QString LiveTvServiceInfo::version() const { return m_version; }
+
 void LiveTvServiceInfo::setVersion(QString newVersion) {
 	m_version = newVersion;
-	emit versionChanged(newVersion);
 }
-
 bool LiveTvServiceInfo::hasUpdateAvailable() const { return m_hasUpdateAvailable; }
+
 void LiveTvServiceInfo::setHasUpdateAvailable(bool newHasUpdateAvailable) {
 	m_hasUpdateAvailable = newHasUpdateAvailable;
-	emit hasUpdateAvailableChanged(newHasUpdateAvailable);
 }
-
 bool LiveTvServiceInfo::isVisible() const { return m_isVisible; }
+
 void LiveTvServiceInfo::setIsVisible(bool newIsVisible) {
 	m_isVisible = newIsVisible;
-	emit isVisibleChanged(newIsVisible);
 }
-
 QStringList LiveTvServiceInfo::tuners() const { return m_tuners; }
+
 void LiveTvServiceInfo::setTuners(QStringList newTuners) {
 	m_tuners = newTuners;
-	emit tunersChanged(newTuners);
 }
 
 

core/src/DTO/localizationoption.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-LocalizationOption::LocalizationOption(QObject *parent) : QObject(parent) {}
+LocalizationOption::LocalizationOption(QObject *parent) {}
 
-LocalizationOption *LocalizationOption::fromJSON(QJsonObject source, QObject *parent) {
-	LocalizationOption *instance = new LocalizationOption(parent);
-	instance->updateFromJSON(source);
+LocalizationOption LocalizationOption::fromJson(QJsonObject source) {LocalizationOption instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LocalizationOption::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LocalizationOption::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_value = fromJsonValue<QString>(source["Value"]);
+
 }
-QJsonObject LocalizationOption::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LocalizationOption::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Value"] = toJsonValue<QString>(m_value);
+
 	return result;
 }
+
 QString LocalizationOption::name() const { return m_name; }
+
 void LocalizationOption::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString LocalizationOption::value() const { return m_value; }
+
 void LocalizationOption::setValue(QString newValue) {
 	m_value = newValue;
-	emit valueChanged(newValue);
 }
 
 

core/src/DTO/logfile.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-LogFile::LogFile(QObject *parent) : QObject(parent) {}
+LogFile::LogFile(QObject *parent) {}
 
-LogFile *LogFile::fromJSON(QJsonObject source, QObject *parent) {
-	LogFile *instance = new LogFile(parent);
-	instance->updateFromJSON(source);
+LogFile LogFile::fromJson(QJsonObject source) {LogFile instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void LogFile::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void LogFile::setFromJson(QJsonObject source) {
+	m_dateCreated = fromJsonValue<QDateTime>(source["DateCreated"]);
+	m_dateModified = fromJsonValue<QDateTime>(source["DateModified"]);
+	m_size = fromJsonValue<qint64>(source["Size"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+
 }
-QJsonObject LogFile::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject LogFile::toJson() {
 	QJsonObject result;
+	result["DateCreated"] = toJsonValue<QDateTime>(m_dateCreated);
+	result["DateModified"] = toJsonValue<QDateTime>(m_dateModified);
+	result["Size"] = toJsonValue<qint64>(m_size);
+	result["Name"] = toJsonValue<QString>(m_name);
+
 	return result;
 }
+
 QDateTime LogFile::dateCreated() const { return m_dateCreated; }
+
 void LogFile::setDateCreated(QDateTime newDateCreated) {
 	m_dateCreated = newDateCreated;
-	emit dateCreatedChanged(newDateCreated);
 }
-
 QDateTime LogFile::dateModified() const { return m_dateModified; }
+
 void LogFile::setDateModified(QDateTime newDateModified) {
 	m_dateModified = newDateModified;
-	emit dateModifiedChanged(newDateModified);
 }
-
 qint64 LogFile::size() const { return m_size; }
+
 void LogFile::setSize(qint64 newSize) {
 	m_size = newSize;
-	emit sizeChanged(newSize);
 }
-
 QString LogFile::name() const { return m_name; }
+
 void LogFile::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
 
 

core/src/DTO/mediaattachment.cpp

@@ -32,62 +32,72 @@
 namespace Jellyfin {
 namespace DTO {
 
-MediaAttachment::MediaAttachment(QObject *parent) : QObject(parent) {}
+MediaAttachment::MediaAttachment(QObject *parent) {}
 
-MediaAttachment *MediaAttachment::fromJSON(QJsonObject source, QObject *parent) {
-	MediaAttachment *instance = new MediaAttachment(parent);
-	instance->updateFromJSON(source);
+MediaAttachment MediaAttachment::fromJson(QJsonObject source) {MediaAttachment instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaAttachment::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaAttachment::setFromJson(QJsonObject source) {
+	m_codec = fromJsonValue<QString>(source["Codec"]);
+	m_codecTag = fromJsonValue<QString>(source["CodecTag"]);
+	m_comment = fromJsonValue<QString>(source["Comment"]);
+	m_index = fromJsonValue<qint32>(source["Index"]);
+	m_fileName = fromJsonValue<QString>(source["FileName"]);
+	m_mimeType = fromJsonValue<QString>(source["MimeType"]);
+	m_deliveryUrl = fromJsonValue<QString>(source["DeliveryUrl"]);
+
 }
-QJsonObject MediaAttachment::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaAttachment::toJson() {
 	QJsonObject result;
+	result["Codec"] = toJsonValue<QString>(m_codec);
+	result["CodecTag"] = toJsonValue<QString>(m_codecTag);
+	result["Comment"] = toJsonValue<QString>(m_comment);
+	result["Index"] = toJsonValue<qint32>(m_index);
+	result["FileName"] = toJsonValue<QString>(m_fileName);
+	result["MimeType"] = toJsonValue<QString>(m_mimeType);
+	result["DeliveryUrl"] = toJsonValue<QString>(m_deliveryUrl);
+
 	return result;
 }
+
 QString MediaAttachment::codec() const { return m_codec; }
+
 void MediaAttachment::setCodec(QString newCodec) {
 	m_codec = newCodec;
-	emit codecChanged(newCodec);
 }
-
 QString MediaAttachment::codecTag() const { return m_codecTag; }
+
 void MediaAttachment::setCodecTag(QString newCodecTag) {
 	m_codecTag = newCodecTag;
-	emit codecTagChanged(newCodecTag);
 }
-
 QString MediaAttachment::comment() const { return m_comment; }
+
 void MediaAttachment::setComment(QString newComment) {
 	m_comment = newComment;
-	emit commentChanged(newComment);
 }
-
 qint32 MediaAttachment::index() const { return m_index; }
+
 void MediaAttachment::setIndex(qint32 newIndex) {
 	m_index = newIndex;
-	emit indexChanged(newIndex);
 }
-
 QString MediaAttachment::fileName() const { return m_fileName; }
+
 void MediaAttachment::setFileName(QString newFileName) {
 	m_fileName = newFileName;
-	emit fileNameChanged(newFileName);
 }
-
 QString MediaAttachment::mimeType() const { return m_mimeType; }
+
 void MediaAttachment::setMimeType(QString newMimeType) {
 	m_mimeType = newMimeType;
-	emit mimeTypeChanged(newMimeType);
 }
-
 QString MediaAttachment::deliveryUrl() const { return m_deliveryUrl; }
+
 void MediaAttachment::setDeliveryUrl(QString newDeliveryUrl) {
 	m_deliveryUrl = newDeliveryUrl;
-	emit deliveryUrlChanged(newDeliveryUrl);
 }
 
 

core/src/DTO/mediaencoderpathdto.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-MediaEncoderPathDto::MediaEncoderPathDto(QObject *parent) : QObject(parent) {}
+MediaEncoderPathDto::MediaEncoderPathDto(QObject *parent) {}
 
-MediaEncoderPathDto *MediaEncoderPathDto::fromJSON(QJsonObject source, QObject *parent) {
-	MediaEncoderPathDto *instance = new MediaEncoderPathDto(parent);
-	instance->updateFromJSON(source);
+MediaEncoderPathDto MediaEncoderPathDto::fromJson(QJsonObject source) {MediaEncoderPathDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaEncoderPathDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaEncoderPathDto::setFromJson(QJsonObject source) {
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_pathType = fromJsonValue<QString>(source["PathType"]);
+
 }
-QJsonObject MediaEncoderPathDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaEncoderPathDto::toJson() {
 	QJsonObject result;
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["PathType"] = toJsonValue<QString>(m_pathType);
+
 	return result;
 }
+
 QString MediaEncoderPathDto::path() const { return m_path; }
+
 void MediaEncoderPathDto::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MediaEncoderPathDto::pathType() const { return m_pathType; }
+
 void MediaEncoderPathDto::setPathType(QString newPathType) {
 	m_pathType = newPathType;
-	emit pathTypeChanged(newPathType);
 }
 
 

core/src/DTO/mediapathdto.cpp

@@ -32,38 +32,44 @@
 namespace Jellyfin {
 namespace DTO {
 
-MediaPathDto::MediaPathDto(QObject *parent) : QObject(parent) {}
+MediaPathDto::MediaPathDto(QObject *parent) {}
 
-MediaPathDto *MediaPathDto::fromJSON(QJsonObject source, QObject *parent) {
-	MediaPathDto *instance = new MediaPathDto(parent);
-	instance->updateFromJSON(source);
+MediaPathDto MediaPathDto::fromJson(QJsonObject source) {MediaPathDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaPathDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaPathDto::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_pathInfo = fromJsonValue<QSharedPointer<MediaPathInfo>>(source["PathInfo"]);
+
 }
-QJsonObject MediaPathDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaPathDto::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["PathInfo"] = toJsonValue<QSharedPointer<MediaPathInfo>>(m_pathInfo);
+
 	return result;
 }
+
 QString MediaPathDto::name() const { return m_name; }
+
 void MediaPathDto::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString MediaPathDto::path() const { return m_path; }
+
 void MediaPathDto::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
+QSharedPointer<MediaPathInfo> MediaPathDto::pathInfo() const { return m_pathInfo; }
 
-MediaPathInfo * MediaPathDto::pathInfo() const { return m_pathInfo; }
-void MediaPathDto::setPathInfo(MediaPathInfo * newPathInfo) {
+void MediaPathDto::setPathInfo(QSharedPointer<MediaPathInfo> newPathInfo) {
 	m_pathInfo = newPathInfo;
-	emit pathInfoChanged(newPathInfo);
 }
 
 

core/src/DTO/mediapathinfo.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-MediaPathInfo::MediaPathInfo(QObject *parent) : QObject(parent) {}
+MediaPathInfo::MediaPathInfo(QObject *parent) {}
 
-MediaPathInfo *MediaPathInfo::fromJSON(QJsonObject source, QObject *parent) {
-	MediaPathInfo *instance = new MediaPathInfo(parent);
-	instance->updateFromJSON(source);
+MediaPathInfo MediaPathInfo::fromJson(QJsonObject source) {MediaPathInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaPathInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaPathInfo::setFromJson(QJsonObject source) {
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_networkPath = fromJsonValue<QString>(source["NetworkPath"]);
+
 }
-QJsonObject MediaPathInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaPathInfo::toJson() {
 	QJsonObject result;
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["NetworkPath"] = toJsonValue<QString>(m_networkPath);
+
 	return result;
 }
+
 QString MediaPathInfo::path() const { return m_path; }
+
 void MediaPathInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MediaPathInfo::networkPath() const { return m_networkPath; }
+
 void MediaPathInfo::setNetworkPath(QString newNetworkPath) {
 	m_networkPath = newNetworkPath;
-	emit networkPathChanged(newNetworkPath);
 }
 
 

core/src/DTO/mediasourceinfo.cpp

@@ -29,282 +29,320 @@
 
 #include <JellyfinQt/DTO/mediasourceinfo.h>
 
-#include <JellyfinQt/DTO/isotype.h>
-#include <JellyfinQt/DTO/mediaprotocol.h>
-#include <JellyfinQt/DTO/mediasourcetype.h>
-#include <JellyfinQt/DTO/transportstreamtimestamp.h>
-#include <JellyfinQt/DTO/video3dformat.h>
-#include <JellyfinQt/DTO/videotype.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-MediaSourceInfo::MediaSourceInfo(QObject *parent) : QObject(parent) {}
+MediaSourceInfo::MediaSourceInfo(QObject *parent) {}
 
-MediaSourceInfo *MediaSourceInfo::fromJSON(QJsonObject source, QObject *parent) {
-	MediaSourceInfo *instance = new MediaSourceInfo(parent);
-	instance->updateFromJSON(source);
+MediaSourceInfo MediaSourceInfo::fromJson(QJsonObject source) {MediaSourceInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaSourceInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaSourceInfo::setFromJson(QJsonObject source) {
+	m_protocol = fromJsonValue<MediaProtocol>(source["Protocol"]);
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_encoderPath = fromJsonValue<QString>(source["EncoderPath"]);
+	m_encoderProtocol = fromJsonValue<MediaProtocol>(source["EncoderProtocol"]);
+	m_type = fromJsonValue<MediaSourceType>(source["Type"]);
+	m_container = fromJsonValue<QString>(source["Container"]);
+	m_size = fromJsonValue<qint64>(source["Size"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_isRemote = fromJsonValue<bool>(source["IsRemote"]);
+	m_eTag = fromJsonValue<QString>(source["ETag"]);
+	m_runTimeTicks = fromJsonValue<qint64>(source["RunTimeTicks"]);
+	m_readAtNativeFramerate = fromJsonValue<bool>(source["ReadAtNativeFramerate"]);
+	m_ignoreDts = fromJsonValue<bool>(source["IgnoreDts"]);
+	m_ignoreIndex = fromJsonValue<bool>(source["IgnoreIndex"]);
+	m_genPtsInput = fromJsonValue<bool>(source["GenPtsInput"]);
+	m_supportsTranscoding = fromJsonValue<bool>(source["SupportsTranscoding"]);
+	m_supportsDirectStream = fromJsonValue<bool>(source["SupportsDirectStream"]);
+	m_supportsDirectPlay = fromJsonValue<bool>(source["SupportsDirectPlay"]);
+	m_isInfiniteStream = fromJsonValue<bool>(source["IsInfiniteStream"]);
+	m_requiresOpening = fromJsonValue<bool>(source["RequiresOpening"]);
+	m_openToken = fromJsonValue<QString>(source["OpenToken"]);
+	m_requiresClosing = fromJsonValue<bool>(source["RequiresClosing"]);
+	m_liveStreamId = fromJsonValue<QString>(source["LiveStreamId"]);
+	m_bufferMs = fromJsonValue<qint32>(source["BufferMs"]);
+	m_requiresLooping = fromJsonValue<bool>(source["RequiresLooping"]);
+	m_supportsProbing = fromJsonValue<bool>(source["SupportsProbing"]);
+	m_videoType = fromJsonValue<VideoType>(source["VideoType"]);
+	m_isoType = fromJsonValue<IsoType>(source["IsoType"]);
+	m_video3DFormat = fromJsonValue<Video3DFormat>(source["Video3DFormat"]);
+	m_mediaStreams = fromJsonValue<QList<QSharedPointer<MediaStream>>>(source["MediaStreams"]);
+	m_mediaAttachments = fromJsonValue<QList<QSharedPointer<MediaAttachment>>>(source["MediaAttachments"]);
+	m_formats = fromJsonValue<QStringList>(source["Formats"]);
+	m_bitrate = fromJsonValue<qint32>(source["Bitrate"]);
+	m_timestamp = fromJsonValue<TransportStreamTimestamp>(source["Timestamp"]);
+	m_requiredHttpHeaders = fromJsonValue<QJsonObject>(source["RequiredHttpHeaders"]);
+	m_transcodingUrl = fromJsonValue<QString>(source["TranscodingUrl"]);
+	m_transcodingSubProtocol = fromJsonValue<QString>(source["TranscodingSubProtocol"]);
+	m_transcodingContainer = fromJsonValue<QString>(source["TranscodingContainer"]);
+	m_analyzeDurationMs = fromJsonValue<qint32>(source["AnalyzeDurationMs"]);
+	m_defaultAudioStreamIndex = fromJsonValue<qint32>(source["DefaultAudioStreamIndex"]);
+	m_defaultSubtitleStreamIndex = fromJsonValue<qint32>(source["DefaultSubtitleStreamIndex"]);
+
 }
-QJsonObject MediaSourceInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaSourceInfo::toJson() {
 	QJsonObject result;
+	result["Protocol"] = toJsonValue<MediaProtocol>(m_protocol);
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["EncoderPath"] = toJsonValue<QString>(m_encoderPath);
+	result["EncoderProtocol"] = toJsonValue<MediaProtocol>(m_encoderProtocol);
+	result["Type"] = toJsonValue<MediaSourceType>(m_type);
+	result["Container"] = toJsonValue<QString>(m_container);
+	result["Size"] = toJsonValue<qint64>(m_size);
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["IsRemote"] = toJsonValue<bool>(m_isRemote);
+	result["ETag"] = toJsonValue<QString>(m_eTag);
+	result["RunTimeTicks"] = toJsonValue<qint64>(m_runTimeTicks);
+	result["ReadAtNativeFramerate"] = toJsonValue<bool>(m_readAtNativeFramerate);
+	result["IgnoreDts"] = toJsonValue<bool>(m_ignoreDts);
+	result["IgnoreIndex"] = toJsonValue<bool>(m_ignoreIndex);
+	result["GenPtsInput"] = toJsonValue<bool>(m_genPtsInput);
+	result["SupportsTranscoding"] = toJsonValue<bool>(m_supportsTranscoding);
+	result["SupportsDirectStream"] = toJsonValue<bool>(m_supportsDirectStream);
+	result["SupportsDirectPlay"] = toJsonValue<bool>(m_supportsDirectPlay);
+	result["IsInfiniteStream"] = toJsonValue<bool>(m_isInfiniteStream);
+	result["RequiresOpening"] = toJsonValue<bool>(m_requiresOpening);
+	result["OpenToken"] = toJsonValue<QString>(m_openToken);
+	result["RequiresClosing"] = toJsonValue<bool>(m_requiresClosing);
+	result["LiveStreamId"] = toJsonValue<QString>(m_liveStreamId);
+	result["BufferMs"] = toJsonValue<qint32>(m_bufferMs);
+	result["RequiresLooping"] = toJsonValue<bool>(m_requiresLooping);
+	result["SupportsProbing"] = toJsonValue<bool>(m_supportsProbing);
+	result["VideoType"] = toJsonValue<VideoType>(m_videoType);
+	result["IsoType"] = toJsonValue<IsoType>(m_isoType);
+	result["Video3DFormat"] = toJsonValue<Video3DFormat>(m_video3DFormat);
+	result["MediaStreams"] = toJsonValue<QList<QSharedPointer<MediaStream>>>(m_mediaStreams);
+	result["MediaAttachments"] = toJsonValue<QList<QSharedPointer<MediaAttachment>>>(m_mediaAttachments);
+	result["Formats"] = toJsonValue<QStringList>(m_formats);
+	result["Bitrate"] = toJsonValue<qint32>(m_bitrate);
+	result["Timestamp"] = toJsonValue<TransportStreamTimestamp>(m_timestamp);
+	result["RequiredHttpHeaders"] = toJsonValue<QJsonObject>(m_requiredHttpHeaders);
+	result["TranscodingUrl"] = toJsonValue<QString>(m_transcodingUrl);
+	result["TranscodingSubProtocol"] = toJsonValue<QString>(m_transcodingSubProtocol);
+	result["TranscodingContainer"] = toJsonValue<QString>(m_transcodingContainer);
+	result["AnalyzeDurationMs"] = toJsonValue<qint32>(m_analyzeDurationMs);
+	result["DefaultAudioStreamIndex"] = toJsonValue<qint32>(m_defaultAudioStreamIndex);
+	result["DefaultSubtitleStreamIndex"] = toJsonValue<qint32>(m_defaultSubtitleStreamIndex);
+
 	return result;
 }
+
 MediaProtocol MediaSourceInfo::protocol() const { return m_protocol; }
+
 void MediaSourceInfo::setProtocol(MediaProtocol newProtocol) {
 	m_protocol = newProtocol;
-	emit protocolChanged(newProtocol);
 }
-
 QString MediaSourceInfo::jellyfinId() const { return m_jellyfinId; }
+
 void MediaSourceInfo::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString MediaSourceInfo::path() const { return m_path; }
+
 void MediaSourceInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MediaSourceInfo::encoderPath() const { return m_encoderPath; }
+
 void MediaSourceInfo::setEncoderPath(QString newEncoderPath) {
 	m_encoderPath = newEncoderPath;
-	emit encoderPathChanged(newEncoderPath);
 }
-
 MediaProtocol MediaSourceInfo::encoderProtocol() const { return m_encoderProtocol; }
+
 void MediaSourceInfo::setEncoderProtocol(MediaProtocol newEncoderProtocol) {
 	m_encoderProtocol = newEncoderProtocol;
-	emit encoderProtocolChanged(newEncoderProtocol);
 }
-
 MediaSourceType MediaSourceInfo::type() const { return m_type; }
+
 void MediaSourceInfo::setType(MediaSourceType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 QString MediaSourceInfo::container() const { return m_container; }
+
 void MediaSourceInfo::setContainer(QString newContainer) {
 	m_container = newContainer;
-	emit containerChanged(newContainer);
 }
-
 qint64 MediaSourceInfo::size() const { return m_size; }
+
 void MediaSourceInfo::setSize(qint64 newSize) {
 	m_size = newSize;
-	emit sizeChanged(newSize);
 }
-
 QString MediaSourceInfo::name() const { return m_name; }
+
 void MediaSourceInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 bool MediaSourceInfo::isRemote() const { return m_isRemote; }
+
 void MediaSourceInfo::setIsRemote(bool newIsRemote) {
 	m_isRemote = newIsRemote;
-	emit isRemoteChanged(newIsRemote);
 }
-
 QString MediaSourceInfo::eTag() const { return m_eTag; }
+
 void MediaSourceInfo::setETag(QString newETag) {
 	m_eTag = newETag;
-	emit eTagChanged(newETag);
 }
-
 qint64 MediaSourceInfo::runTimeTicks() const { return m_runTimeTicks; }
+
 void MediaSourceInfo::setRunTimeTicks(qint64 newRunTimeTicks) {
 	m_runTimeTicks = newRunTimeTicks;
-	emit runTimeTicksChanged(newRunTimeTicks);
 }
-
 bool MediaSourceInfo::readAtNativeFramerate() const { return m_readAtNativeFramerate; }
+
 void MediaSourceInfo::setReadAtNativeFramerate(bool newReadAtNativeFramerate) {
 	m_readAtNativeFramerate = newReadAtNativeFramerate;
-	emit readAtNativeFramerateChanged(newReadAtNativeFramerate);
 }
-
 bool MediaSourceInfo::ignoreDts() const { return m_ignoreDts; }
+
 void MediaSourceInfo::setIgnoreDts(bool newIgnoreDts) {
 	m_ignoreDts = newIgnoreDts;
-	emit ignoreDtsChanged(newIgnoreDts);
 }
-
 bool MediaSourceInfo::ignoreIndex() const { return m_ignoreIndex; }
+
 void MediaSourceInfo::setIgnoreIndex(bool newIgnoreIndex) {
 	m_ignoreIndex = newIgnoreIndex;
-	emit ignoreIndexChanged(newIgnoreIndex);
 }
-
 bool MediaSourceInfo::genPtsInput() const { return m_genPtsInput; }
+
 void MediaSourceInfo::setGenPtsInput(bool newGenPtsInput) {
 	m_genPtsInput = newGenPtsInput;
-	emit genPtsInputChanged(newGenPtsInput);
 }
-
 bool MediaSourceInfo::supportsTranscoding() const { return m_supportsTranscoding; }
+
 void MediaSourceInfo::setSupportsTranscoding(bool newSupportsTranscoding) {
 	m_supportsTranscoding = newSupportsTranscoding;
-	emit supportsTranscodingChanged(newSupportsTranscoding);
 }
-
 bool MediaSourceInfo::supportsDirectStream() const { return m_supportsDirectStream; }
+
 void MediaSourceInfo::setSupportsDirectStream(bool newSupportsDirectStream) {
 	m_supportsDirectStream = newSupportsDirectStream;
-	emit supportsDirectStreamChanged(newSupportsDirectStream);
 }
-
 bool MediaSourceInfo::supportsDirectPlay() const { return m_supportsDirectPlay; }
+
 void MediaSourceInfo::setSupportsDirectPlay(bool newSupportsDirectPlay) {
 	m_supportsDirectPlay = newSupportsDirectPlay;
-	emit supportsDirectPlayChanged(newSupportsDirectPlay);
 }
-
 bool MediaSourceInfo::isInfiniteStream() const { return m_isInfiniteStream; }
+
 void MediaSourceInfo::setIsInfiniteStream(bool newIsInfiniteStream) {
 	m_isInfiniteStream = newIsInfiniteStream;
-	emit isInfiniteStreamChanged(newIsInfiniteStream);
 }
-
 bool MediaSourceInfo::requiresOpening() const { return m_requiresOpening; }
+
 void MediaSourceInfo::setRequiresOpening(bool newRequiresOpening) {
 	m_requiresOpening = newRequiresOpening;
-	emit requiresOpeningChanged(newRequiresOpening);
 }
-
 QString MediaSourceInfo::openToken() const { return m_openToken; }
+
 void MediaSourceInfo::setOpenToken(QString newOpenToken) {
 	m_openToken = newOpenToken;
-	emit openTokenChanged(newOpenToken);
 }
-
 bool MediaSourceInfo::requiresClosing() const { return m_requiresClosing; }
+
 void MediaSourceInfo::setRequiresClosing(bool newRequiresClosing) {
 	m_requiresClosing = newRequiresClosing;
-	emit requiresClosingChanged(newRequiresClosing);
 }
-
 QString MediaSourceInfo::liveStreamId() const { return m_liveStreamId; }
+
 void MediaSourceInfo::setLiveStreamId(QString newLiveStreamId) {
 	m_liveStreamId = newLiveStreamId;
-	emit liveStreamIdChanged(newLiveStreamId);
 }
-
 qint32 MediaSourceInfo::bufferMs() const { return m_bufferMs; }
+
 void MediaSourceInfo::setBufferMs(qint32 newBufferMs) {
 	m_bufferMs = newBufferMs;
-	emit bufferMsChanged(newBufferMs);
 }
-
 bool MediaSourceInfo::requiresLooping() const { return m_requiresLooping; }
+
 void MediaSourceInfo::setRequiresLooping(bool newRequiresLooping) {
 	m_requiresLooping = newRequiresLooping;
-	emit requiresLoopingChanged(newRequiresLooping);
 }
-
 bool MediaSourceInfo::supportsProbing() const { return m_supportsProbing; }
+
 void MediaSourceInfo::setSupportsProbing(bool newSupportsProbing) {
 	m_supportsProbing = newSupportsProbing;
-	emit supportsProbingChanged(newSupportsProbing);
 }
-
 VideoType MediaSourceInfo::videoType() const { return m_videoType; }
+
 void MediaSourceInfo::setVideoType(VideoType newVideoType) {
 	m_videoType = newVideoType;
-	emit videoTypeChanged(newVideoType);
 }
-
 IsoType MediaSourceInfo::isoType() const { return m_isoType; }
+
 void MediaSourceInfo::setIsoType(IsoType newIsoType) {
 	m_isoType = newIsoType;
-	emit isoTypeChanged(newIsoType);
 }
-
 Video3DFormat MediaSourceInfo::video3DFormat() const { return m_video3DFormat; }
+
 void MediaSourceInfo::setVideo3DFormat(Video3DFormat newVideo3DFormat) {
 	m_video3DFormat = newVideo3DFormat;
-	emit video3DFormatChanged(newVideo3DFormat);
 }
+QList<QSharedPointer<MediaStream>> MediaSourceInfo::mediaStreams() const { return m_mediaStreams; }
 
-QList<MediaStream *> MediaSourceInfo::mediaStreams() const { return m_mediaStreams; }
-void MediaSourceInfo::setMediaStreams(QList<MediaStream *> newMediaStreams) {
+void MediaSourceInfo::setMediaStreams(QList<QSharedPointer<MediaStream>> newMediaStreams) {
 	m_mediaStreams = newMediaStreams;
-	emit mediaStreamsChanged(newMediaStreams);
 }
+QList<QSharedPointer<MediaAttachment>> MediaSourceInfo::mediaAttachments() const { return m_mediaAttachments; }
 
-QList<MediaAttachment *> MediaSourceInfo::mediaAttachments() const { return m_mediaAttachments; }
-void MediaSourceInfo::setMediaAttachments(QList<MediaAttachment *> newMediaAttachments) {
+void MediaSourceInfo::setMediaAttachments(QList<QSharedPointer<MediaAttachment>> newMediaAttachments) {
 	m_mediaAttachments = newMediaAttachments;
-	emit mediaAttachmentsChanged(newMediaAttachments);
 }
-
 QStringList MediaSourceInfo::formats() const { return m_formats; }
+
 void MediaSourceInfo::setFormats(QStringList newFormats) {
 	m_formats = newFormats;
-	emit formatsChanged(newFormats);
 }
-
 qint32 MediaSourceInfo::bitrate() const { return m_bitrate; }
+
 void MediaSourceInfo::setBitrate(qint32 newBitrate) {
 	m_bitrate = newBitrate;
-	emit bitrateChanged(newBitrate);
 }
-
 TransportStreamTimestamp MediaSourceInfo::timestamp() const { return m_timestamp; }
+
 void MediaSourceInfo::setTimestamp(TransportStreamTimestamp newTimestamp) {
 	m_timestamp = newTimestamp;
-	emit timestampChanged(newTimestamp);
 }
-
 QJsonObject MediaSourceInfo::requiredHttpHeaders() const { return m_requiredHttpHeaders; }
+
 void MediaSourceInfo::setRequiredHttpHeaders(QJsonObject newRequiredHttpHeaders) {
 	m_requiredHttpHeaders = newRequiredHttpHeaders;
-	emit requiredHttpHeadersChanged(newRequiredHttpHeaders);
 }
-
 QString MediaSourceInfo::transcodingUrl() const { return m_transcodingUrl; }
+
 void MediaSourceInfo::setTranscodingUrl(QString newTranscodingUrl) {
 	m_transcodingUrl = newTranscodingUrl;
-	emit transcodingUrlChanged(newTranscodingUrl);
 }
-
 QString MediaSourceInfo::transcodingSubProtocol() const { return m_transcodingSubProtocol; }
+
 void MediaSourceInfo::setTranscodingSubProtocol(QString newTranscodingSubProtocol) {
 	m_transcodingSubProtocol = newTranscodingSubProtocol;
-	emit transcodingSubProtocolChanged(newTranscodingSubProtocol);
 }
-
 QString MediaSourceInfo::transcodingContainer() const { return m_transcodingContainer; }
+
 void MediaSourceInfo::setTranscodingContainer(QString newTranscodingContainer) {
 	m_transcodingContainer = newTranscodingContainer;
-	emit transcodingContainerChanged(newTranscodingContainer);
 }
-
 qint32 MediaSourceInfo::analyzeDurationMs() const { return m_analyzeDurationMs; }
+
 void MediaSourceInfo::setAnalyzeDurationMs(qint32 newAnalyzeDurationMs) {
 	m_analyzeDurationMs = newAnalyzeDurationMs;
-	emit analyzeDurationMsChanged(newAnalyzeDurationMs);
 }
-
 qint32 MediaSourceInfo::defaultAudioStreamIndex() const { return m_defaultAudioStreamIndex; }
+
 void MediaSourceInfo::setDefaultAudioStreamIndex(qint32 newDefaultAudioStreamIndex) {
 	m_defaultAudioStreamIndex = newDefaultAudioStreamIndex;
-	emit defaultAudioStreamIndexChanged(newDefaultAudioStreamIndex);
 }
-
 qint32 MediaSourceInfo::defaultSubtitleStreamIndex() const { return m_defaultSubtitleStreamIndex; }
+
 void MediaSourceInfo::setDefaultSubtitleStreamIndex(qint32 newDefaultSubtitleStreamIndex) {
 	m_defaultSubtitleStreamIndex = newDefaultSubtitleStreamIndex;
-	emit defaultSubtitleStreamIndexChanged(newDefaultSubtitleStreamIndex);
 }
 
 

core/src/DTO/mediastream.cpp

@@ -29,308 +29,355 @@
 
 #include <JellyfinQt/DTO/mediastream.h>
 
-#include <JellyfinQt/DTO/mediastreamtype.h>
-#include <JellyfinQt/DTO/subtitledeliverymethod.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-MediaStream::MediaStream(QObject *parent) : QObject(parent) {}
+MediaStream::MediaStream(QObject *parent) {}
 
-MediaStream *MediaStream::fromJSON(QJsonObject source, QObject *parent) {
-	MediaStream *instance = new MediaStream(parent);
-	instance->updateFromJSON(source);
+MediaStream MediaStream::fromJson(QJsonObject source) {MediaStream instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaStream::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaStream::setFromJson(QJsonObject source) {
+	m_codec = fromJsonValue<QString>(source["Codec"]);
+	m_codecTag = fromJsonValue<QString>(source["CodecTag"]);
+	m_language = fromJsonValue<QString>(source["Language"]);
+	m_colorRange = fromJsonValue<QString>(source["ColorRange"]);
+	m_colorSpace = fromJsonValue<QString>(source["ColorSpace"]);
+	m_colorTransfer = fromJsonValue<QString>(source["ColorTransfer"]);
+	m_colorPrimaries = fromJsonValue<QString>(source["ColorPrimaries"]);
+	m_comment = fromJsonValue<QString>(source["Comment"]);
+	m_timeBase = fromJsonValue<QString>(source["TimeBase"]);
+	m_codecTimeBase = fromJsonValue<QString>(source["CodecTimeBase"]);
+	m_title = fromJsonValue<QString>(source["Title"]);
+	m_videoRange = fromJsonValue<QString>(source["VideoRange"]);
+	m_localizedUndefined = fromJsonValue<QString>(source["localizedUndefined"]);
+	m_localizedDefault = fromJsonValue<QString>(source["localizedDefault"]);
+	m_localizedForced = fromJsonValue<QString>(source["localizedForced"]);
+	m_displayTitle = fromJsonValue<QString>(source["DisplayTitle"]);
+	m_nalLengthSize = fromJsonValue<QString>(source["NalLengthSize"]);
+	m_isInterlaced = fromJsonValue<bool>(source["IsInterlaced"]);
+	m_isAVC = fromJsonValue<bool>(source["IsAVC"]);
+	m_channelLayout = fromJsonValue<QString>(source["ChannelLayout"]);
+	m_bitRate = fromJsonValue<qint32>(source["BitRate"]);
+	m_bitDepth = fromJsonValue<qint32>(source["BitDepth"]);
+	m_refFrames = fromJsonValue<qint32>(source["RefFrames"]);
+	m_packetLength = fromJsonValue<qint32>(source["PacketLength"]);
+	m_channels = fromJsonValue<qint32>(source["Channels"]);
+	m_sampleRate = fromJsonValue<qint32>(source["SampleRate"]);
+	m_isDefault = fromJsonValue<bool>(source["IsDefault"]);
+	m_isForced = fromJsonValue<bool>(source["IsForced"]);
+	m_height = fromJsonValue<qint32>(source["Height"]);
+	m_width = fromJsonValue<qint32>(source["Width"]);
+	m_averageFrameRate = fromJsonValue<float>(source["AverageFrameRate"]);
+	m_realFrameRate = fromJsonValue<float>(source["RealFrameRate"]);
+	m_profile = fromJsonValue<QString>(source["Profile"]);
+	m_type = fromJsonValue<MediaStreamType>(source["Type"]);
+	m_aspectRatio = fromJsonValue<QString>(source["AspectRatio"]);
+	m_index = fromJsonValue<qint32>(source["Index"]);
+	m_score = fromJsonValue<qint32>(source["Score"]);
+	m_isExternal = fromJsonValue<bool>(source["IsExternal"]);
+	m_deliveryMethod = fromJsonValue<SubtitleDeliveryMethod>(source["DeliveryMethod"]);
+	m_deliveryUrl = fromJsonValue<QString>(source["DeliveryUrl"]);
+	m_isExternalUrl = fromJsonValue<bool>(source["IsExternalUrl"]);
+	m_isTextSubtitleStream = fromJsonValue<bool>(source["IsTextSubtitleStream"]);
+	m_supportsExternalStream = fromJsonValue<bool>(source["SupportsExternalStream"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_pixelFormat = fromJsonValue<QString>(source["PixelFormat"]);
+	m_level = fromJsonValue<double>(source["Level"]);
+	m_isAnamorphic = fromJsonValue<bool>(source["IsAnamorphic"]);
+
 }
-QJsonObject MediaStream::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaStream::toJson() {
 	QJsonObject result;
+	result["Codec"] = toJsonValue<QString>(m_codec);
+	result["CodecTag"] = toJsonValue<QString>(m_codecTag);
+	result["Language"] = toJsonValue<QString>(m_language);
+	result["ColorRange"] = toJsonValue<QString>(m_colorRange);
+	result["ColorSpace"] = toJsonValue<QString>(m_colorSpace);
+	result["ColorTransfer"] = toJsonValue<QString>(m_colorTransfer);
+	result["ColorPrimaries"] = toJsonValue<QString>(m_colorPrimaries);
+	result["Comment"] = toJsonValue<QString>(m_comment);
+	result["TimeBase"] = toJsonValue<QString>(m_timeBase);
+	result["CodecTimeBase"] = toJsonValue<QString>(m_codecTimeBase);
+	result["Title"] = toJsonValue<QString>(m_title);
+	result["VideoRange"] = toJsonValue<QString>(m_videoRange);
+	result["localizedUndefined"] = toJsonValue<QString>(m_localizedUndefined);
+	result["localizedDefault"] = toJsonValue<QString>(m_localizedDefault);
+	result["localizedForced"] = toJsonValue<QString>(m_localizedForced);
+	result["DisplayTitle"] = toJsonValue<QString>(m_displayTitle);
+	result["NalLengthSize"] = toJsonValue<QString>(m_nalLengthSize);
+	result["IsInterlaced"] = toJsonValue<bool>(m_isInterlaced);
+	result["IsAVC"] = toJsonValue<bool>(m_isAVC);
+	result["ChannelLayout"] = toJsonValue<QString>(m_channelLayout);
+	result["BitRate"] = toJsonValue<qint32>(m_bitRate);
+	result["BitDepth"] = toJsonValue<qint32>(m_bitDepth);
+	result["RefFrames"] = toJsonValue<qint32>(m_refFrames);
+	result["PacketLength"] = toJsonValue<qint32>(m_packetLength);
+	result["Channels"] = toJsonValue<qint32>(m_channels);
+	result["SampleRate"] = toJsonValue<qint32>(m_sampleRate);
+	result["IsDefault"] = toJsonValue<bool>(m_isDefault);
+	result["IsForced"] = toJsonValue<bool>(m_isForced);
+	result["Height"] = toJsonValue<qint32>(m_height);
+	result["Width"] = toJsonValue<qint32>(m_width);
+	result["AverageFrameRate"] = toJsonValue<float>(m_averageFrameRate);
+	result["RealFrameRate"] = toJsonValue<float>(m_realFrameRate);
+	result["Profile"] = toJsonValue<QString>(m_profile);
+	result["Type"] = toJsonValue<MediaStreamType>(m_type);
+	result["AspectRatio"] = toJsonValue<QString>(m_aspectRatio);
+	result["Index"] = toJsonValue<qint32>(m_index);
+	result["Score"] = toJsonValue<qint32>(m_score);
+	result["IsExternal"] = toJsonValue<bool>(m_isExternal);
+	result["DeliveryMethod"] = toJsonValue<SubtitleDeliveryMethod>(m_deliveryMethod);
+	result["DeliveryUrl"] = toJsonValue<QString>(m_deliveryUrl);
+	result["IsExternalUrl"] = toJsonValue<bool>(m_isExternalUrl);
+	result["IsTextSubtitleStream"] = toJsonValue<bool>(m_isTextSubtitleStream);
+	result["SupportsExternalStream"] = toJsonValue<bool>(m_supportsExternalStream);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["PixelFormat"] = toJsonValue<QString>(m_pixelFormat);
+	result["Level"] = toJsonValue<double>(m_level);
+	result["IsAnamorphic"] = toJsonValue<bool>(m_isAnamorphic);
+
 	return result;
 }
+
 QString MediaStream::codec() const { return m_codec; }
+
 void MediaStream::setCodec(QString newCodec) {
 	m_codec = newCodec;
-	emit codecChanged(newCodec);
 }
-
 QString MediaStream::codecTag() const { return m_codecTag; }
+
 void MediaStream::setCodecTag(QString newCodecTag) {
 	m_codecTag = newCodecTag;
-	emit codecTagChanged(newCodecTag);
 }
-
 QString MediaStream::language() const { return m_language; }
+
 void MediaStream::setLanguage(QString newLanguage) {
 	m_language = newLanguage;
-	emit languageChanged(newLanguage);
 }
-
 QString MediaStream::colorRange() const { return m_colorRange; }
+
 void MediaStream::setColorRange(QString newColorRange) {
 	m_colorRange = newColorRange;
-	emit colorRangeChanged(newColorRange);
 }
-
 QString MediaStream::colorSpace() const { return m_colorSpace; }
+
 void MediaStream::setColorSpace(QString newColorSpace) {
 	m_colorSpace = newColorSpace;
-	emit colorSpaceChanged(newColorSpace);
 }
-
 QString MediaStream::colorTransfer() const { return m_colorTransfer; }
+
 void MediaStream::setColorTransfer(QString newColorTransfer) {
 	m_colorTransfer = newColorTransfer;
-	emit colorTransferChanged(newColorTransfer);
 }
-
 QString MediaStream::colorPrimaries() const { return m_colorPrimaries; }
+
 void MediaStream::setColorPrimaries(QString newColorPrimaries) {
 	m_colorPrimaries = newColorPrimaries;
-	emit colorPrimariesChanged(newColorPrimaries);
 }
-
 QString MediaStream::comment() const { return m_comment; }
+
 void MediaStream::setComment(QString newComment) {
 	m_comment = newComment;
-	emit commentChanged(newComment);
 }
-
 QString MediaStream::timeBase() const { return m_timeBase; }
+
 void MediaStream::setTimeBase(QString newTimeBase) {
 	m_timeBase = newTimeBase;
-	emit timeBaseChanged(newTimeBase);
 }
-
 QString MediaStream::codecTimeBase() const { return m_codecTimeBase; }
+
 void MediaStream::setCodecTimeBase(QString newCodecTimeBase) {
 	m_codecTimeBase = newCodecTimeBase;
-	emit codecTimeBaseChanged(newCodecTimeBase);
 }
-
 QString MediaStream::title() const { return m_title; }
+
 void MediaStream::setTitle(QString newTitle) {
 	m_title = newTitle;
-	emit titleChanged(newTitle);
 }
-
 QString MediaStream::videoRange() const { return m_videoRange; }
+
 void MediaStream::setVideoRange(QString newVideoRange) {
 	m_videoRange = newVideoRange;
-	emit videoRangeChanged(newVideoRange);
 }
-
 QString MediaStream::localizedUndefined() const { return m_localizedUndefined; }
+
 void MediaStream::setLocalizedUndefined(QString newLocalizedUndefined) {
 	m_localizedUndefined = newLocalizedUndefined;
-	emit localizedUndefinedChanged(newLocalizedUndefined);
 }
-
 QString MediaStream::localizedDefault() const { return m_localizedDefault; }
+
 void MediaStream::setLocalizedDefault(QString newLocalizedDefault) {
 	m_localizedDefault = newLocalizedDefault;
-	emit localizedDefaultChanged(newLocalizedDefault);
 }
-
 QString MediaStream::localizedForced() const { return m_localizedForced; }
+
 void MediaStream::setLocalizedForced(QString newLocalizedForced) {
 	m_localizedForced = newLocalizedForced;
-	emit localizedForcedChanged(newLocalizedForced);
 }
-
 QString MediaStream::displayTitle() const { return m_displayTitle; }
+
 void MediaStream::setDisplayTitle(QString newDisplayTitle) {
 	m_displayTitle = newDisplayTitle;
-	emit displayTitleChanged(newDisplayTitle);
 }
-
 QString MediaStream::nalLengthSize() const { return m_nalLengthSize; }
+
 void MediaStream::setNalLengthSize(QString newNalLengthSize) {
 	m_nalLengthSize = newNalLengthSize;
-	emit nalLengthSizeChanged(newNalLengthSize);
 }
-
 bool MediaStream::isInterlaced() const { return m_isInterlaced; }
+
 void MediaStream::setIsInterlaced(bool newIsInterlaced) {
 	m_isInterlaced = newIsInterlaced;
-	emit isInterlacedChanged(newIsInterlaced);
 }
-
 bool MediaStream::isAVC() const { return m_isAVC; }
+
 void MediaStream::setIsAVC(bool newIsAVC) {
 	m_isAVC = newIsAVC;
-	emit isAVCChanged(newIsAVC);
 }
-
 QString MediaStream::channelLayout() const { return m_channelLayout; }
+
 void MediaStream::setChannelLayout(QString newChannelLayout) {
 	m_channelLayout = newChannelLayout;
-	emit channelLayoutChanged(newChannelLayout);
 }
-
 qint32 MediaStream::bitRate() const { return m_bitRate; }
+
 void MediaStream::setBitRate(qint32 newBitRate) {
 	m_bitRate = newBitRate;
-	emit bitRateChanged(newBitRate);
 }
-
 qint32 MediaStream::bitDepth() const { return m_bitDepth; }
+
 void MediaStream::setBitDepth(qint32 newBitDepth) {
 	m_bitDepth = newBitDepth;
-	emit bitDepthChanged(newBitDepth);
 }
-
 qint32 MediaStream::refFrames() const { return m_refFrames; }
+
 void MediaStream::setRefFrames(qint32 newRefFrames) {
 	m_refFrames = newRefFrames;
-	emit refFramesChanged(newRefFrames);
 }
-
 qint32 MediaStream::packetLength() const { return m_packetLength; }
+
 void MediaStream::setPacketLength(qint32 newPacketLength) {
 	m_packetLength = newPacketLength;
-	emit packetLengthChanged(newPacketLength);
 }
-
 qint32 MediaStream::channels() const { return m_channels; }
+
 void MediaStream::setChannels(qint32 newChannels) {
 	m_channels = newChannels;
-	emit channelsChanged(newChannels);
 }
-
 qint32 MediaStream::sampleRate() const { return m_sampleRate; }
+
 void MediaStream::setSampleRate(qint32 newSampleRate) {
 	m_sampleRate = newSampleRate;
-	emit sampleRateChanged(newSampleRate);
 }
-
 bool MediaStream::isDefault() const { return m_isDefault; }
+
 void MediaStream::setIsDefault(bool newIsDefault) {
 	m_isDefault = newIsDefault;
-	emit isDefaultChanged(newIsDefault);
 }
-
 bool MediaStream::isForced() const { return m_isForced; }
+
 void MediaStream::setIsForced(bool newIsForced) {
 	m_isForced = newIsForced;
-	emit isForcedChanged(newIsForced);
 }
-
 qint32 MediaStream::height() const { return m_height; }
+
 void MediaStream::setHeight(qint32 newHeight) {
 	m_height = newHeight;
-	emit heightChanged(newHeight);
 }
-
 qint32 MediaStream::width() const { return m_width; }
+
 void MediaStream::setWidth(qint32 newWidth) {
 	m_width = newWidth;
-	emit widthChanged(newWidth);
 }
-
 float MediaStream::averageFrameRate() const { return m_averageFrameRate; }
+
 void MediaStream::setAverageFrameRate(float newAverageFrameRate) {
 	m_averageFrameRate = newAverageFrameRate;
-	emit averageFrameRateChanged(newAverageFrameRate);
 }
-
 float MediaStream::realFrameRate() const { return m_realFrameRate; }
+
 void MediaStream::setRealFrameRate(float newRealFrameRate) {
 	m_realFrameRate = newRealFrameRate;
-	emit realFrameRateChanged(newRealFrameRate);
 }
-
 QString MediaStream::profile() const { return m_profile; }
+
 void MediaStream::setProfile(QString newProfile) {
 	m_profile = newProfile;
-	emit profileChanged(newProfile);
 }
-
 MediaStreamType MediaStream::type() const { return m_type; }
+
 void MediaStream::setType(MediaStreamType newType) {
 	m_type = newType;
-	emit typeChanged(newType);
 }
-
 QString MediaStream::aspectRatio() const { return m_aspectRatio; }
+
 void MediaStream::setAspectRatio(QString newAspectRatio) {
 	m_aspectRatio = newAspectRatio;
-	emit aspectRatioChanged(newAspectRatio);
 }
-
 qint32 MediaStream::index() const { return m_index; }
+
 void MediaStream::setIndex(qint32 newIndex) {
 	m_index = newIndex;
-	emit indexChanged(newIndex);
 }
-
 qint32 MediaStream::score() const { return m_score; }
+
 void MediaStream::setScore(qint32 newScore) {
 	m_score = newScore;
-	emit scoreChanged(newScore);
 }
-
 bool MediaStream::isExternal() const { return m_isExternal; }
+
 void MediaStream::setIsExternal(bool newIsExternal) {
 	m_isExternal = newIsExternal;
-	emit isExternalChanged(newIsExternal);
 }
-
 SubtitleDeliveryMethod MediaStream::deliveryMethod() const { return m_deliveryMethod; }
+
 void MediaStream::setDeliveryMethod(SubtitleDeliveryMethod newDeliveryMethod) {
 	m_deliveryMethod = newDeliveryMethod;
-	emit deliveryMethodChanged(newDeliveryMethod);
 }
-
 QString MediaStream::deliveryUrl() const { return m_deliveryUrl; }
+
 void MediaStream::setDeliveryUrl(QString newDeliveryUrl) {
 	m_deliveryUrl = newDeliveryUrl;
-	emit deliveryUrlChanged(newDeliveryUrl);
 }
-
 bool MediaStream::isExternalUrl() const { return m_isExternalUrl; }
+
 void MediaStream::setIsExternalUrl(bool newIsExternalUrl) {
 	m_isExternalUrl = newIsExternalUrl;
-	emit isExternalUrlChanged(newIsExternalUrl);
 }
-
 bool MediaStream::isTextSubtitleStream() const { return m_isTextSubtitleStream; }
+
 void MediaStream::setIsTextSubtitleStream(bool newIsTextSubtitleStream) {
 	m_isTextSubtitleStream = newIsTextSubtitleStream;
-	emit isTextSubtitleStreamChanged(newIsTextSubtitleStream);
 }
-
 bool MediaStream::supportsExternalStream() const { return m_supportsExternalStream; }
+
 void MediaStream::setSupportsExternalStream(bool newSupportsExternalStream) {
 	m_supportsExternalStream = newSupportsExternalStream;
-	emit supportsExternalStreamChanged(newSupportsExternalStream);
 }
-
 QString MediaStream::path() const { return m_path; }
+
 void MediaStream::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MediaStream::pixelFormat() const { return m_pixelFormat; }
+
 void MediaStream::setPixelFormat(QString newPixelFormat) {
 	m_pixelFormat = newPixelFormat;
-	emit pixelFormatChanged(newPixelFormat);
 }
-
 double MediaStream::level() const { return m_level; }
+
 void MediaStream::setLevel(double newLevel) {
 	m_level = newLevel;
-	emit levelChanged(newLevel);
 }
-
 bool MediaStream::isAnamorphic() const { return m_isAnamorphic; }
+
 void MediaStream::setIsAnamorphic(bool newIsAnamorphic) {
 	m_isAnamorphic = newIsAnamorphic;
-	emit isAnamorphicChanged(newIsAnamorphic);
 }
 
 

core/src/DTO/mediaupdateinfodto.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-MediaUpdateInfoDto::MediaUpdateInfoDto(QObject *parent) : QObject(parent) {}
+MediaUpdateInfoDto::MediaUpdateInfoDto(QObject *parent) {}
 
-MediaUpdateInfoDto *MediaUpdateInfoDto::fromJSON(QJsonObject source, QObject *parent) {
-	MediaUpdateInfoDto *instance = new MediaUpdateInfoDto(parent);
-	instance->updateFromJSON(source);
+MediaUpdateInfoDto MediaUpdateInfoDto::fromJson(QJsonObject source) {MediaUpdateInfoDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaUpdateInfoDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaUpdateInfoDto::setFromJson(QJsonObject source) {
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_updateType = fromJsonValue<QString>(source["UpdateType"]);
+
 }
-QJsonObject MediaUpdateInfoDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaUpdateInfoDto::toJson() {
 	QJsonObject result;
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["UpdateType"] = toJsonValue<QString>(m_updateType);
+
 	return result;
 }
+
 QString MediaUpdateInfoDto::path() const { return m_path; }
+
 void MediaUpdateInfoDto::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MediaUpdateInfoDto::updateType() const { return m_updateType; }
+
 void MediaUpdateInfoDto::setUpdateType(QString newUpdateType) {
 	m_updateType = newUpdateType;
-	emit updateTypeChanged(newUpdateType);
 }
 
 

core/src/DTO/mediaurl.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-MediaUrl::MediaUrl(QObject *parent) : QObject(parent) {}
+MediaUrl::MediaUrl(QObject *parent) {}
 
-MediaUrl *MediaUrl::fromJSON(QJsonObject source, QObject *parent) {
-	MediaUrl *instance = new MediaUrl(parent);
-	instance->updateFromJSON(source);
+MediaUrl MediaUrl::fromJson(QJsonObject source) {MediaUrl instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MediaUrl::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MediaUrl::setFromJson(QJsonObject source) {
+	m_url = fromJsonValue<QString>(source["Url"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+
 }
-QJsonObject MediaUrl::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MediaUrl::toJson() {
 	QJsonObject result;
+	result["Url"] = toJsonValue<QString>(m_url);
+	result["Name"] = toJsonValue<QString>(m_name);
+
 	return result;
 }
+
 QString MediaUrl::url() const { return m_url; }
+
 void MediaUrl::setUrl(QString newUrl) {
 	m_url = newUrl;
-	emit urlChanged(newUrl);
 }
-
 QString MediaUrl::name() const { return m_name; }
+
 void MediaUrl::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
 
 

core/src/DTO/metadataeditorinfo.cpp

@@ -32,56 +32,65 @@
 namespace Jellyfin {
 namespace DTO {
 
-MetadataEditorInfo::MetadataEditorInfo(QObject *parent) : QObject(parent) {}
+MetadataEditorInfo::MetadataEditorInfo(QObject *parent) {}
 
-MetadataEditorInfo *MetadataEditorInfo::fromJSON(QJsonObject source, QObject *parent) {
-	MetadataEditorInfo *instance = new MetadataEditorInfo(parent);
-	instance->updateFromJSON(source);
+MetadataEditorInfo MetadataEditorInfo::fromJson(QJsonObject source) {MetadataEditorInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MetadataEditorInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MetadataEditorInfo::setFromJson(QJsonObject source) {
+	m_parentalRatingOptions = fromJsonValue<QList<QSharedPointer<ParentalRating>>>(source["ParentalRatingOptions"]);
+	m_countries = fromJsonValue<QList<QSharedPointer<CountryInfo>>>(source["Countries"]);
+	m_cultures = fromJsonValue<QList<QSharedPointer<CultureDto>>>(source["Cultures"]);
+	m_externalIdInfos = fromJsonValue<QList<QSharedPointer<ExternalIdInfo>>>(source["ExternalIdInfos"]);
+	m_contentType = fromJsonValue<QString>(source["ContentType"]);
+	m_contentTypeOptions = fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["ContentTypeOptions"]);
+
 }
-QJsonObject MetadataEditorInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MetadataEditorInfo::toJson() {
 	QJsonObject result;
+	result["ParentalRatingOptions"] = toJsonValue<QList<QSharedPointer<ParentalRating>>>(m_parentalRatingOptions);
+	result["Countries"] = toJsonValue<QList<QSharedPointer<CountryInfo>>>(m_countries);
+	result["Cultures"] = toJsonValue<QList<QSharedPointer<CultureDto>>>(m_cultures);
+	result["ExternalIdInfos"] = toJsonValue<QList<QSharedPointer<ExternalIdInfo>>>(m_externalIdInfos);
+	result["ContentType"] = toJsonValue<QString>(m_contentType);
+	result["ContentTypeOptions"] = toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_contentTypeOptions);
+
 	return result;
 }
-QList<ParentalRating *> MetadataEditorInfo::parentalRatingOptions() const { return m_parentalRatingOptions; }
-void MetadataEditorInfo::setParentalRatingOptions(QList<ParentalRating *> newParentalRatingOptions) {
+
+QList<QSharedPointer<ParentalRating>> MetadataEditorInfo::parentalRatingOptions() const { return m_parentalRatingOptions; }
+
+void MetadataEditorInfo::setParentalRatingOptions(QList<QSharedPointer<ParentalRating>> newParentalRatingOptions) {
 	m_parentalRatingOptions = newParentalRatingOptions;
-	emit parentalRatingOptionsChanged(newParentalRatingOptions);
 }
+QList<QSharedPointer<CountryInfo>> MetadataEditorInfo::countries() const { return m_countries; }
 
-QList<CountryInfo *> MetadataEditorInfo::countries() const { return m_countries; }
-void MetadataEditorInfo::setCountries(QList<CountryInfo *> newCountries) {
+void MetadataEditorInfo::setCountries(QList<QSharedPointer<CountryInfo>> newCountries) {
 	m_countries = newCountries;
-	emit countriesChanged(newCountries);
 }
+QList<QSharedPointer<CultureDto>> MetadataEditorInfo::cultures() const { return m_cultures; }
 
-QList<CultureDto *> MetadataEditorInfo::cultures() const { return m_cultures; }
-void MetadataEditorInfo::setCultures(QList<CultureDto *> newCultures) {
+void MetadataEditorInfo::setCultures(QList<QSharedPointer<CultureDto>> newCultures) {
 	m_cultures = newCultures;
-	emit culturesChanged(newCultures);
 }
+QList<QSharedPointer<ExternalIdInfo>> MetadataEditorInfo::externalIdInfos() const { return m_externalIdInfos; }
 
-QList<ExternalIdInfo *> MetadataEditorInfo::externalIdInfos() const { return m_externalIdInfos; }
-void MetadataEditorInfo::setExternalIdInfos(QList<ExternalIdInfo *> newExternalIdInfos) {
+void MetadataEditorInfo::setExternalIdInfos(QList<QSharedPointer<ExternalIdInfo>> newExternalIdInfos) {
 	m_externalIdInfos = newExternalIdInfos;
-	emit externalIdInfosChanged(newExternalIdInfos);
 }
-
 QString MetadataEditorInfo::contentType() const { return m_contentType; }
+
 void MetadataEditorInfo::setContentType(QString newContentType) {
 	m_contentType = newContentType;
-	emit contentTypeChanged(newContentType);
 }
+QList<QSharedPointer<NameValuePair>> MetadataEditorInfo::contentTypeOptions() const { return m_contentTypeOptions; }
 
-QList<NameValuePair *> MetadataEditorInfo::contentTypeOptions() const { return m_contentTypeOptions; }
-void MetadataEditorInfo::setContentTypeOptions(QList<NameValuePair *> newContentTypeOptions) {
+void MetadataEditorInfo::setContentTypeOptions(QList<QSharedPointer<NameValuePair>> newContentTypeOptions) {
 	m_contentTypeOptions = newContentTypeOptions;
-	emit contentTypeOptionsChanged(newContentTypeOptions);
 }
 
 

core/src/DTO/metadataoptions.cpp

@@ -32,62 +32,72 @@
 namespace Jellyfin {
 namespace DTO {
 
-MetadataOptions::MetadataOptions(QObject *parent) : QObject(parent) {}
+MetadataOptions::MetadataOptions(QObject *parent) {}
 
-MetadataOptions *MetadataOptions::fromJSON(QJsonObject source, QObject *parent) {
-	MetadataOptions *instance = new MetadataOptions(parent);
-	instance->updateFromJSON(source);
+MetadataOptions MetadataOptions::fromJson(QJsonObject source) {MetadataOptions instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MetadataOptions::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MetadataOptions::setFromJson(QJsonObject source) {
+	m_itemType = fromJsonValue<QString>(source["ItemType"]);
+	m_disabledMetadataSavers = fromJsonValue<QStringList>(source["DisabledMetadataSavers"]);
+	m_localMetadataReaderOrder = fromJsonValue<QStringList>(source["LocalMetadataReaderOrder"]);
+	m_disabledMetadataFetchers = fromJsonValue<QStringList>(source["DisabledMetadataFetchers"]);
+	m_metadataFetcherOrder = fromJsonValue<QStringList>(source["MetadataFetcherOrder"]);
+	m_disabledImageFetchers = fromJsonValue<QStringList>(source["DisabledImageFetchers"]);
+	m_imageFetcherOrder = fromJsonValue<QStringList>(source["ImageFetcherOrder"]);
+
 }
-QJsonObject MetadataOptions::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MetadataOptions::toJson() {
 	QJsonObject result;
+	result["ItemType"] = toJsonValue<QString>(m_itemType);
+	result["DisabledMetadataSavers"] = toJsonValue<QStringList>(m_disabledMetadataSavers);
+	result["LocalMetadataReaderOrder"] = toJsonValue<QStringList>(m_localMetadataReaderOrder);
+	result["DisabledMetadataFetchers"] = toJsonValue<QStringList>(m_disabledMetadataFetchers);
+	result["MetadataFetcherOrder"] = toJsonValue<QStringList>(m_metadataFetcherOrder);
+	result["DisabledImageFetchers"] = toJsonValue<QStringList>(m_disabledImageFetchers);
+	result["ImageFetcherOrder"] = toJsonValue<QStringList>(m_imageFetcherOrder);
+
 	return result;
 }
+
 QString MetadataOptions::itemType() const { return m_itemType; }
+
 void MetadataOptions::setItemType(QString newItemType) {
 	m_itemType = newItemType;
-	emit itemTypeChanged(newItemType);
 }
-
 QStringList MetadataOptions::disabledMetadataSavers() const { return m_disabledMetadataSavers; }
+
 void MetadataOptions::setDisabledMetadataSavers(QStringList newDisabledMetadataSavers) {
 	m_disabledMetadataSavers = newDisabledMetadataSavers;
-	emit disabledMetadataSaversChanged(newDisabledMetadataSavers);
 }
-
 QStringList MetadataOptions::localMetadataReaderOrder() const { return m_localMetadataReaderOrder; }
+
 void MetadataOptions::setLocalMetadataReaderOrder(QStringList newLocalMetadataReaderOrder) {
 	m_localMetadataReaderOrder = newLocalMetadataReaderOrder;
-	emit localMetadataReaderOrderChanged(newLocalMetadataReaderOrder);
 }
-
 QStringList MetadataOptions::disabledMetadataFetchers() const { return m_disabledMetadataFetchers; }
+
 void MetadataOptions::setDisabledMetadataFetchers(QStringList newDisabledMetadataFetchers) {
 	m_disabledMetadataFetchers = newDisabledMetadataFetchers;
-	emit disabledMetadataFetchersChanged(newDisabledMetadataFetchers);
 }
-
 QStringList MetadataOptions::metadataFetcherOrder() const { return m_metadataFetcherOrder; }
+
 void MetadataOptions::setMetadataFetcherOrder(QStringList newMetadataFetcherOrder) {
 	m_metadataFetcherOrder = newMetadataFetcherOrder;
-	emit metadataFetcherOrderChanged(newMetadataFetcherOrder);
 }
-
 QStringList MetadataOptions::disabledImageFetchers() const { return m_disabledImageFetchers; }
+
 void MetadataOptions::setDisabledImageFetchers(QStringList newDisabledImageFetchers) {
 	m_disabledImageFetchers = newDisabledImageFetchers;
-	emit disabledImageFetchersChanged(newDisabledImageFetchers);
 }
-
 QStringList MetadataOptions::imageFetcherOrder() const { return m_imageFetcherOrder; }
+
 void MetadataOptions::setImageFetcherOrder(QStringList newImageFetcherOrder) {
 	m_imageFetcherOrder = newImageFetcherOrder;
-	emit imageFetcherOrderChanged(newImageFetcherOrder);
 }
 
 

core/src/DTO/moveplaylistitemrequestdto.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-MovePlaylistItemRequestDto::MovePlaylistItemRequestDto(QObject *parent) : QObject(parent) {}
+MovePlaylistItemRequestDto::MovePlaylistItemRequestDto(QObject *parent) {}
 
-MovePlaylistItemRequestDto *MovePlaylistItemRequestDto::fromJSON(QJsonObject source, QObject *parent) {
-	MovePlaylistItemRequestDto *instance = new MovePlaylistItemRequestDto(parent);
-	instance->updateFromJSON(source);
+MovePlaylistItemRequestDto MovePlaylistItemRequestDto::fromJson(QJsonObject source) {MovePlaylistItemRequestDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MovePlaylistItemRequestDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MovePlaylistItemRequestDto::setFromJson(QJsonObject source) {
+	m_playlistItemId = fromJsonValue<QUuid>(source["PlaylistItemId"]);
+	m_newIndex = fromJsonValue<qint32>(source["NewIndex"]);
+
 }
-QJsonObject MovePlaylistItemRequestDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MovePlaylistItemRequestDto::toJson() {
 	QJsonObject result;
+	result["PlaylistItemId"] = toJsonValue<QUuid>(m_playlistItemId);
+	result["NewIndex"] = toJsonValue<qint32>(m_newIndex);
+
 	return result;
 }
-QString MovePlaylistItemRequestDto::playlistItemId() const { return m_playlistItemId; }
-void MovePlaylistItemRequestDto::setPlaylistItemId(QString newPlaylistItemId) {
-	m_playlistItemId = newPlaylistItemId;
-	emit playlistItemIdChanged(newPlaylistItemId);
-}
 
+QUuid MovePlaylistItemRequestDto::playlistItemId() const { return m_playlistItemId; }
+
+void MovePlaylistItemRequestDto::setPlaylistItemId(QUuid newPlaylistItemId) {
+	m_playlistItemId = newPlaylistItemId;
+}
 qint32 MovePlaylistItemRequestDto::newIndex() const { return m_newIndex; }
+
 void MovePlaylistItemRequestDto::setNewIndex(qint32 newNewIndex) {
 	m_newIndex = newNewIndex;
-	emit newIndexChanged(newNewIndex);
 }
 
 

core/src/DTO/movieinfo.cpp

@@ -32,80 +32,93 @@
 namespace Jellyfin {
 namespace DTO {
 
-MovieInfo::MovieInfo(QObject *parent) : QObject(parent) {}
+MovieInfo::MovieInfo(QObject *parent) {}
 
-MovieInfo *MovieInfo::fromJSON(QJsonObject source, QObject *parent) {
-	MovieInfo *instance = new MovieInfo(parent);
-	instance->updateFromJSON(source);
+MovieInfo MovieInfo::fromJson(QJsonObject source) {MovieInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MovieInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MovieInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_metadataLanguage = fromJsonValue<QString>(source["MetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_providerIds = fromJsonValue<QJsonObject>(source["ProviderIds"]);
+	m_year = fromJsonValue<qint32>(source["Year"]);
+	m_indexNumber = fromJsonValue<qint32>(source["IndexNumber"]);
+	m_parentIndexNumber = fromJsonValue<qint32>(source["ParentIndexNumber"]);
+	m_premiereDate = fromJsonValue<QDateTime>(source["PremiereDate"]);
+	m_isAutomated = fromJsonValue<bool>(source["IsAutomated"]);
+
 }
-QJsonObject MovieInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MovieInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["MetadataLanguage"] = toJsonValue<QString>(m_metadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["ProviderIds"] = toJsonValue<QJsonObject>(m_providerIds);
+	result["Year"] = toJsonValue<qint32>(m_year);
+	result["IndexNumber"] = toJsonValue<qint32>(m_indexNumber);
+	result["ParentIndexNumber"] = toJsonValue<qint32>(m_parentIndexNumber);
+	result["PremiereDate"] = toJsonValue<QDateTime>(m_premiereDate);
+	result["IsAutomated"] = toJsonValue<bool>(m_isAutomated);
+
 	return result;
 }
+
 QString MovieInfo::name() const { return m_name; }
+
 void MovieInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString MovieInfo::path() const { return m_path; }
+
 void MovieInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MovieInfo::metadataLanguage() const { return m_metadataLanguage; }
+
 void MovieInfo::setMetadataLanguage(QString newMetadataLanguage) {
 	m_metadataLanguage = newMetadataLanguage;
-	emit metadataLanguageChanged(newMetadataLanguage);
 }
-
 QString MovieInfo::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void MovieInfo::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QJsonObject MovieInfo::providerIds() const { return m_providerIds; }
+
 void MovieInfo::setProviderIds(QJsonObject newProviderIds) {
 	m_providerIds = newProviderIds;
-	emit providerIdsChanged(newProviderIds);
 }
-
 qint32 MovieInfo::year() const { return m_year; }
+
 void MovieInfo::setYear(qint32 newYear) {
 	m_year = newYear;
-	emit yearChanged(newYear);
 }
-
 qint32 MovieInfo::indexNumber() const { return m_indexNumber; }
+
 void MovieInfo::setIndexNumber(qint32 newIndexNumber) {
 	m_indexNumber = newIndexNumber;
-	emit indexNumberChanged(newIndexNumber);
 }
-
 qint32 MovieInfo::parentIndexNumber() const { return m_parentIndexNumber; }
+
 void MovieInfo::setParentIndexNumber(qint32 newParentIndexNumber) {
 	m_parentIndexNumber = newParentIndexNumber;
-	emit parentIndexNumberChanged(newParentIndexNumber);
 }
-
 QDateTime MovieInfo::premiereDate() const { return m_premiereDate; }
+
 void MovieInfo::setPremiereDate(QDateTime newPremiereDate) {
 	m_premiereDate = newPremiereDate;
-	emit premiereDateChanged(newPremiereDate);
 }
-
 bool MovieInfo::isAutomated() const { return m_isAutomated; }
+
 void MovieInfo::setIsAutomated(bool newIsAutomated) {
 	m_isAutomated = newIsAutomated;
-	emit isAutomatedChanged(newIsAutomated);
 }
 
 

core/src/DTO/movieinforemotesearchquery.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-MovieInfoRemoteSearchQuery::MovieInfoRemoteSearchQuery(QObject *parent) : QObject(parent) {}
+MovieInfoRemoteSearchQuery::MovieInfoRemoteSearchQuery(QObject *parent) {}
 
-MovieInfoRemoteSearchQuery *MovieInfoRemoteSearchQuery::fromJSON(QJsonObject source, QObject *parent) {
-	MovieInfoRemoteSearchQuery *instance = new MovieInfoRemoteSearchQuery(parent);
-	instance->updateFromJSON(source);
+MovieInfoRemoteSearchQuery MovieInfoRemoteSearchQuery::fromJson(QJsonObject source) {MovieInfoRemoteSearchQuery instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MovieInfoRemoteSearchQuery::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MovieInfoRemoteSearchQuery::setFromJson(QJsonObject source) {
+	m_searchInfo = fromJsonValue<QSharedPointer<MovieInfo>>(source["SearchInfo"]);
+	m_itemId = fromJsonValue<QUuid>(source["ItemId"]);
+	m_searchProviderName = fromJsonValue<QString>(source["SearchProviderName"]);
+	m_includeDisabledProviders = fromJsonValue<bool>(source["IncludeDisabledProviders"]);
+
 }
-QJsonObject MovieInfoRemoteSearchQuery::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MovieInfoRemoteSearchQuery::toJson() {
 	QJsonObject result;
+	result["SearchInfo"] = toJsonValue<QSharedPointer<MovieInfo>>(m_searchInfo);
+	result["ItemId"] = toJsonValue<QUuid>(m_itemId);
+	result["SearchProviderName"] = toJsonValue<QString>(m_searchProviderName);
+	result["IncludeDisabledProviders"] = toJsonValue<bool>(m_includeDisabledProviders);
+
 	return result;
 }
-MovieInfo * MovieInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
-void MovieInfoRemoteSearchQuery::setSearchInfo(MovieInfo * newSearchInfo) {
+
+QSharedPointer<MovieInfo> MovieInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
+
+void MovieInfoRemoteSearchQuery::setSearchInfo(QSharedPointer<MovieInfo> newSearchInfo) {
 	m_searchInfo = newSearchInfo;
-	emit searchInfoChanged(newSearchInfo);
 }
+QUuid MovieInfoRemoteSearchQuery::itemId() const { return m_itemId; }
 
-QString MovieInfoRemoteSearchQuery::itemId() const { return m_itemId; }
-void MovieInfoRemoteSearchQuery::setItemId(QString newItemId) {
+void MovieInfoRemoteSearchQuery::setItemId(QUuid newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QString MovieInfoRemoteSearchQuery::searchProviderName() const { return m_searchProviderName; }
+
 void MovieInfoRemoteSearchQuery::setSearchProviderName(QString newSearchProviderName) {
 	m_searchProviderName = newSearchProviderName;
-	emit searchProviderNameChanged(newSearchProviderName);
 }
-
 bool MovieInfoRemoteSearchQuery::includeDisabledProviders() const { return m_includeDisabledProviders; }
+
 void MovieInfoRemoteSearchQuery::setIncludeDisabledProviders(bool newIncludeDisabledProviders) {
 	m_includeDisabledProviders = newIncludeDisabledProviders;
-	emit includeDisabledProvidersChanged(newIncludeDisabledProviders);
 }
 
 

core/src/DTO/musicvideoinfo.cpp

@@ -32,86 +32,100 @@
 namespace Jellyfin {
 namespace DTO {
 
-MusicVideoInfo::MusicVideoInfo(QObject *parent) : QObject(parent) {}
+MusicVideoInfo::MusicVideoInfo(QObject *parent) {}
 
-MusicVideoInfo *MusicVideoInfo::fromJSON(QJsonObject source, QObject *parent) {
-	MusicVideoInfo *instance = new MusicVideoInfo(parent);
-	instance->updateFromJSON(source);
+MusicVideoInfo MusicVideoInfo::fromJson(QJsonObject source) {MusicVideoInfo instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MusicVideoInfo::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MusicVideoInfo::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_path = fromJsonValue<QString>(source["Path"]);
+	m_metadataLanguage = fromJsonValue<QString>(source["MetadataLanguage"]);
+	m_metadataCountryCode = fromJsonValue<QString>(source["MetadataCountryCode"]);
+	m_providerIds = fromJsonValue<QJsonObject>(source["ProviderIds"]);
+	m_year = fromJsonValue<qint32>(source["Year"]);
+	m_indexNumber = fromJsonValue<qint32>(source["IndexNumber"]);
+	m_parentIndexNumber = fromJsonValue<qint32>(source["ParentIndexNumber"]);
+	m_premiereDate = fromJsonValue<QDateTime>(source["PremiereDate"]);
+	m_isAutomated = fromJsonValue<bool>(source["IsAutomated"]);
+	m_artists = fromJsonValue<QStringList>(source["Artists"]);
+
 }
-QJsonObject MusicVideoInfo::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MusicVideoInfo::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Path"] = toJsonValue<QString>(m_path);
+	result["MetadataLanguage"] = toJsonValue<QString>(m_metadataLanguage);
+	result["MetadataCountryCode"] = toJsonValue<QString>(m_metadataCountryCode);
+	result["ProviderIds"] = toJsonValue<QJsonObject>(m_providerIds);
+	result["Year"] = toJsonValue<qint32>(m_year);
+	result["IndexNumber"] = toJsonValue<qint32>(m_indexNumber);
+	result["ParentIndexNumber"] = toJsonValue<qint32>(m_parentIndexNumber);
+	result["PremiereDate"] = toJsonValue<QDateTime>(m_premiereDate);
+	result["IsAutomated"] = toJsonValue<bool>(m_isAutomated);
+	result["Artists"] = toJsonValue<QStringList>(m_artists);
+
 	return result;
 }
+
 QString MusicVideoInfo::name() const { return m_name; }
+
 void MusicVideoInfo::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString MusicVideoInfo::path() const { return m_path; }
+
 void MusicVideoInfo::setPath(QString newPath) {
 	m_path = newPath;
-	emit pathChanged(newPath);
 }
-
 QString MusicVideoInfo::metadataLanguage() const { return m_metadataLanguage; }
+
 void MusicVideoInfo::setMetadataLanguage(QString newMetadataLanguage) {
 	m_metadataLanguage = newMetadataLanguage;
-	emit metadataLanguageChanged(newMetadataLanguage);
 }
-
 QString MusicVideoInfo::metadataCountryCode() const { return m_metadataCountryCode; }
+
 void MusicVideoInfo::setMetadataCountryCode(QString newMetadataCountryCode) {
 	m_metadataCountryCode = newMetadataCountryCode;
-	emit metadataCountryCodeChanged(newMetadataCountryCode);
 }
-
 QJsonObject MusicVideoInfo::providerIds() const { return m_providerIds; }
+
 void MusicVideoInfo::setProviderIds(QJsonObject newProviderIds) {
 	m_providerIds = newProviderIds;
-	emit providerIdsChanged(newProviderIds);
 }
-
 qint32 MusicVideoInfo::year() const { return m_year; }
+
 void MusicVideoInfo::setYear(qint32 newYear) {
 	m_year = newYear;
-	emit yearChanged(newYear);
 }
-
 qint32 MusicVideoInfo::indexNumber() const { return m_indexNumber; }
+
 void MusicVideoInfo::setIndexNumber(qint32 newIndexNumber) {
 	m_indexNumber = newIndexNumber;
-	emit indexNumberChanged(newIndexNumber);
 }
-
 qint32 MusicVideoInfo::parentIndexNumber() const { return m_parentIndexNumber; }
+
 void MusicVideoInfo::setParentIndexNumber(qint32 newParentIndexNumber) {
 	m_parentIndexNumber = newParentIndexNumber;
-	emit parentIndexNumberChanged(newParentIndexNumber);
 }
-
 QDateTime MusicVideoInfo::premiereDate() const { return m_premiereDate; }
+
 void MusicVideoInfo::setPremiereDate(QDateTime newPremiereDate) {
 	m_premiereDate = newPremiereDate;
-	emit premiereDateChanged(newPremiereDate);
 }
-
 bool MusicVideoInfo::isAutomated() const { return m_isAutomated; }
+
 void MusicVideoInfo::setIsAutomated(bool newIsAutomated) {
 	m_isAutomated = newIsAutomated;
-	emit isAutomatedChanged(newIsAutomated);
 }
-
 QStringList MusicVideoInfo::artists() const { return m_artists; }
+
 void MusicVideoInfo::setArtists(QStringList newArtists) {
 	m_artists = newArtists;
-	emit artistsChanged(newArtists);
 }
 
 

core/src/DTO/musicvideoinforemotesearchquery.cpp

@@ -32,44 +32,51 @@
 namespace Jellyfin {
 namespace DTO {
 
-MusicVideoInfoRemoteSearchQuery::MusicVideoInfoRemoteSearchQuery(QObject *parent) : QObject(parent) {}
+MusicVideoInfoRemoteSearchQuery::MusicVideoInfoRemoteSearchQuery(QObject *parent) {}
 
-MusicVideoInfoRemoteSearchQuery *MusicVideoInfoRemoteSearchQuery::fromJSON(QJsonObject source, QObject *parent) {
-	MusicVideoInfoRemoteSearchQuery *instance = new MusicVideoInfoRemoteSearchQuery(parent);
-	instance->updateFromJSON(source);
+MusicVideoInfoRemoteSearchQuery MusicVideoInfoRemoteSearchQuery::fromJson(QJsonObject source) {MusicVideoInfoRemoteSearchQuery instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void MusicVideoInfoRemoteSearchQuery::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void MusicVideoInfoRemoteSearchQuery::setFromJson(QJsonObject source) {
+	m_searchInfo = fromJsonValue<QSharedPointer<MusicVideoInfo>>(source["SearchInfo"]);
+	m_itemId = fromJsonValue<QUuid>(source["ItemId"]);
+	m_searchProviderName = fromJsonValue<QString>(source["SearchProviderName"]);
+	m_includeDisabledProviders = fromJsonValue<bool>(source["IncludeDisabledProviders"]);
+
 }
-QJsonObject MusicVideoInfoRemoteSearchQuery::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject MusicVideoInfoRemoteSearchQuery::toJson() {
 	QJsonObject result;
+	result["SearchInfo"] = toJsonValue<QSharedPointer<MusicVideoInfo>>(m_searchInfo);
+	result["ItemId"] = toJsonValue<QUuid>(m_itemId);
+	result["SearchProviderName"] = toJsonValue<QString>(m_searchProviderName);
+	result["IncludeDisabledProviders"] = toJsonValue<bool>(m_includeDisabledProviders);
+
 	return result;
 }
-MusicVideoInfo * MusicVideoInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
-void MusicVideoInfoRemoteSearchQuery::setSearchInfo(MusicVideoInfo * newSearchInfo) {
+
+QSharedPointer<MusicVideoInfo> MusicVideoInfoRemoteSearchQuery::searchInfo() const { return m_searchInfo; }
+
+void MusicVideoInfoRemoteSearchQuery::setSearchInfo(QSharedPointer<MusicVideoInfo> newSearchInfo) {
 	m_searchInfo = newSearchInfo;
-	emit searchInfoChanged(newSearchInfo);
 }
+QUuid MusicVideoInfoRemoteSearchQuery::itemId() const { return m_itemId; }
 
-QString MusicVideoInfoRemoteSearchQuery::itemId() const { return m_itemId; }
-void MusicVideoInfoRemoteSearchQuery::setItemId(QString newItemId) {
+void MusicVideoInfoRemoteSearchQuery::setItemId(QUuid newItemId) {
 	m_itemId = newItemId;
-	emit itemIdChanged(newItemId);
 }
-
 QString MusicVideoInfoRemoteSearchQuery::searchProviderName() const { return m_searchProviderName; }
+
 void MusicVideoInfoRemoteSearchQuery::setSearchProviderName(QString newSearchProviderName) {
 	m_searchProviderName = newSearchProviderName;
-	emit searchProviderNameChanged(newSearchProviderName);
 }
-
 bool MusicVideoInfoRemoteSearchQuery::includeDisabledProviders() const { return m_includeDisabledProviders; }
+
 void MusicVideoInfoRemoteSearchQuery::setIncludeDisabledProviders(bool newIncludeDisabledProviders) {
 	m_includeDisabledProviders = newIncludeDisabledProviders;
-	emit includeDisabledProvidersChanged(newIncludeDisabledProviders);
 }
 
 

core/src/DTO/nameguidpair.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-NameGuidPair::NameGuidPair(QObject *parent) : QObject(parent) {}
+NameGuidPair::NameGuidPair(QObject *parent) {}
 
-NameGuidPair *NameGuidPair::fromJSON(QJsonObject source, QObject *parent) {
-	NameGuidPair *instance = new NameGuidPair(parent);
-	instance->updateFromJSON(source);
+NameGuidPair NameGuidPair::fromJson(QJsonObject source) {NameGuidPair instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NameGuidPair::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NameGuidPair::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_jellyfinId = fromJsonValue<QUuid>(source["Id"]);
+
 }
-QJsonObject NameGuidPair::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NameGuidPair::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Id"] = toJsonValue<QUuid>(m_jellyfinId);
+
 	return result;
 }
+
 QString NameGuidPair::name() const { return m_name; }
+
 void NameGuidPair::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
+QUuid NameGuidPair::jellyfinId() const { return m_jellyfinId; }
 
-QString NameGuidPair::jellyfinId() const { return m_jellyfinId; }
-void NameGuidPair::setJellyfinId(QString newJellyfinId) {
+void NameGuidPair::setJellyfinId(QUuid newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
 
 

core/src/DTO/nameidpair.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-NameIdPair::NameIdPair(QObject *parent) : QObject(parent) {}
+NameIdPair::NameIdPair(QObject *parent) {}
 
-NameIdPair *NameIdPair::fromJSON(QJsonObject source, QObject *parent) {
-	NameIdPair *instance = new NameIdPair(parent);
-	instance->updateFromJSON(source);
+NameIdPair NameIdPair::fromJson(QJsonObject source) {NameIdPair instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NameIdPair::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NameIdPair::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+
 }
-QJsonObject NameIdPair::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NameIdPair::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+
 	return result;
 }
+
 QString NameIdPair::name() const { return m_name; }
+
 void NameIdPair::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString NameIdPair::jellyfinId() const { return m_jellyfinId; }
+
 void NameIdPair::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
 
 

core/src/DTO/namevaluepair.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-NameValuePair::NameValuePair(QObject *parent) : QObject(parent) {}
+NameValuePair::NameValuePair(QObject *parent) {}
 
-NameValuePair *NameValuePair::fromJSON(QJsonObject source, QObject *parent) {
-	NameValuePair *instance = new NameValuePair(parent);
-	instance->updateFromJSON(source);
+NameValuePair NameValuePair::fromJson(QJsonObject source) {NameValuePair instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NameValuePair::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NameValuePair::setFromJson(QJsonObject source) {
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_value = fromJsonValue<QString>(source["Value"]);
+
 }
-QJsonObject NameValuePair::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NameValuePair::toJson() {
 	QJsonObject result;
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Value"] = toJsonValue<QString>(m_value);
+
 	return result;
 }
+
 QString NameValuePair::name() const { return m_name; }
+
 void NameValuePair::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString NameValuePair::value() const { return m_value; }
+
 void NameValuePair::setValue(QString newValue) {
 	m_value = newValue;
-	emit valueChanged(newValue);
 }
 
 

core/src/DTO/newgrouprequestdto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-NewGroupRequestDto::NewGroupRequestDto(QObject *parent) : QObject(parent) {}
+NewGroupRequestDto::NewGroupRequestDto(QObject *parent) {}
 
-NewGroupRequestDto *NewGroupRequestDto::fromJSON(QJsonObject source, QObject *parent) {
-	NewGroupRequestDto *instance = new NewGroupRequestDto(parent);
-	instance->updateFromJSON(source);
+NewGroupRequestDto NewGroupRequestDto::fromJson(QJsonObject source) {NewGroupRequestDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NewGroupRequestDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NewGroupRequestDto::setFromJson(QJsonObject source) {
+	m_groupName = fromJsonValue<QString>(source["GroupName"]);
+
 }
-QJsonObject NewGroupRequestDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NewGroupRequestDto::toJson() {
 	QJsonObject result;
+	result["GroupName"] = toJsonValue<QString>(m_groupName);
+
 	return result;
 }
+
 QString NewGroupRequestDto::groupName() const { return m_groupName; }
+
 void NewGroupRequestDto::setGroupName(QString newGroupName) {
 	m_groupName = newGroupName;
-	emit groupNameChanged(newGroupName);
 }
 
 

core/src/DTO/nextitemrequestdto.cpp

@@ -32,26 +32,30 @@
 namespace Jellyfin {
 namespace DTO {
 
-NextItemRequestDto::NextItemRequestDto(QObject *parent) : QObject(parent) {}
+NextItemRequestDto::NextItemRequestDto(QObject *parent) {}
 
-NextItemRequestDto *NextItemRequestDto::fromJSON(QJsonObject source, QObject *parent) {
-	NextItemRequestDto *instance = new NextItemRequestDto(parent);
-	instance->updateFromJSON(source);
+NextItemRequestDto NextItemRequestDto::fromJson(QJsonObject source) {NextItemRequestDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NextItemRequestDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NextItemRequestDto::setFromJson(QJsonObject source) {
+	m_playlistItemId = fromJsonValue<QUuid>(source["PlaylistItemId"]);
+
 }
-QJsonObject NextItemRequestDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NextItemRequestDto::toJson() {
 	QJsonObject result;
+	result["PlaylistItemId"] = toJsonValue<QUuid>(m_playlistItemId);
+
 	return result;
 }
-QString NextItemRequestDto::playlistItemId() const { return m_playlistItemId; }
-void NextItemRequestDto::setPlaylistItemId(QString newPlaylistItemId) {
+
+QUuid NextItemRequestDto::playlistItemId() const { return m_playlistItemId; }
+
+void NextItemRequestDto::setPlaylistItemId(QUuid newPlaylistItemId) {
 	m_playlistItemId = newPlaylistItemId;
-	emit playlistItemIdChanged(newPlaylistItemId);
 }
 
 

core/src/DTO/notificationdto.cpp

@@ -29,73 +29,82 @@
 
 #include <JellyfinQt/DTO/notificationdto.h>
 
-#include <JellyfinQt/DTO/notificationlevel.h>
-
 namespace Jellyfin {
 namespace DTO {
 
-NotificationDto::NotificationDto(QObject *parent) : QObject(parent) {}
+NotificationDto::NotificationDto(QObject *parent) {}
 
-NotificationDto *NotificationDto::fromJSON(QJsonObject source, QObject *parent) {
-	NotificationDto *instance = new NotificationDto(parent);
-	instance->updateFromJSON(source);
+NotificationDto NotificationDto::fromJson(QJsonObject source) {NotificationDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NotificationDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NotificationDto::setFromJson(QJsonObject source) {
+	m_jellyfinId = fromJsonValue<QString>(source["Id"]);
+	m_userId = fromJsonValue<QString>(source["UserId"]);
+	m_date = fromJsonValue<QDateTime>(source["Date"]);
+	m_isRead = fromJsonValue<bool>(source["IsRead"]);
+	m_name = fromJsonValue<QString>(source["Name"]);
+	m_description = fromJsonValue<QString>(source["Description"]);
+	m_url = fromJsonValue<QString>(source["Url"]);
+	m_level = fromJsonValue<NotificationLevel>(source["Level"]);
+
 }
-QJsonObject NotificationDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NotificationDto::toJson() {
 	QJsonObject result;
+	result["Id"] = toJsonValue<QString>(m_jellyfinId);
+	result["UserId"] = toJsonValue<QString>(m_userId);
+	result["Date"] = toJsonValue<QDateTime>(m_date);
+	result["IsRead"] = toJsonValue<bool>(m_isRead);
+	result["Name"] = toJsonValue<QString>(m_name);
+	result["Description"] = toJsonValue<QString>(m_description);
+	result["Url"] = toJsonValue<QString>(m_url);
+	result["Level"] = toJsonValue<NotificationLevel>(m_level);
+
 	return result;
 }
+
 QString NotificationDto::jellyfinId() const { return m_jellyfinId; }
+
 void NotificationDto::setJellyfinId(QString newJellyfinId) {
 	m_jellyfinId = newJellyfinId;
-	emit jellyfinIdChanged(newJellyfinId);
 }
-
 QString NotificationDto::userId() const { return m_userId; }
+
 void NotificationDto::setUserId(QString newUserId) {
 	m_userId = newUserId;
-	emit userIdChanged(newUserId);
 }
-
 QDateTime NotificationDto::date() const { return m_date; }
+
 void NotificationDto::setDate(QDateTime newDate) {
 	m_date = newDate;
-	emit dateChanged(newDate);
 }
-
 bool NotificationDto::isRead() const { return m_isRead; }
+
 void NotificationDto::setIsRead(bool newIsRead) {
 	m_isRead = newIsRead;
-	emit isReadChanged(newIsRead);
 }
-
 QString NotificationDto::name() const { return m_name; }
+
 void NotificationDto::setName(QString newName) {
 	m_name = newName;
-	emit nameChanged(newName);
 }
-
 QString NotificationDto::description() const { return m_description; }
+
 void NotificationDto::setDescription(QString newDescription) {
 	m_description = newDescription;
-	emit descriptionChanged(newDescription);
 }
-
 QString NotificationDto::url() const { return m_url; }
+
 void NotificationDto::setUrl(QString newUrl) {
 	m_url = newUrl;
-	emit urlChanged(newUrl);
 }
-
 NotificationLevel NotificationDto::level() const { return m_level; }
+
 void NotificationDto::setLevel(NotificationLevel newLevel) {
 	m_level = newLevel;
-	emit levelChanged(newLevel);
 }
 
 

core/src/DTO/notificationresultdto.cpp

@@ -32,32 +32,37 @@
 namespace Jellyfin {
 namespace DTO {
 
-NotificationResultDto::NotificationResultDto(QObject *parent) : QObject(parent) {}
+NotificationResultDto::NotificationResultDto(QObject *parent) {}
 
-NotificationResultDto *NotificationResultDto::fromJSON(QJsonObject source, QObject *parent) {
-	NotificationResultDto *instance = new NotificationResultDto(parent);
-	instance->updateFromJSON(source);
+NotificationResultDto NotificationResultDto::fromJson(QJsonObject source) {NotificationResultDto instance;
+	instance->setFromJson(source, false);
 	return instance;
 }
 
-void NotificationResultDto::updateFromJSON(QJsonObject source) {
-	Q_UNIMPLEMENTED();
+
+void NotificationResultDto::setFromJson(QJsonObject source) {
+	m_notifications = fromJsonValue<QList<QSharedPointer<NotificationDto>>>(source["Notifications"]);
+	m_totalRecordCount = fromJsonValue<qint32>(source["TotalRecordCount"]);
+
 }
-QJsonObject NotificationResultDto::toJSON() {
-	Q_UNIMPLEMENTED();
+	
+QJsonObject NotificationResultDto::toJson() {
 	QJsonObject result;
+	result["Notifications"] = toJsonValue<QList<QSharedPointer<NotificationDto>>>(m_notifications);
+	result["TotalRecordCount"] = toJsonValue<qint32>(m_totalRecordCount);
+
 	return result;
 }
-QList<NotificationDto *> NotificationResultDto::notifications() const { return m_notifications; }
-void NotificationResultDto::setNotifications(QList<NotificationDto *> newNotifications) {
-	m_notifications = newNotifications;
-	emit notificationsChanged(newNotifications);
-}
 
+QList<QSharedPointer<NotificationDto>> NotificationResultDto::notifications() const { return m_notifications; }
+
+void NotificationResultDto::setNotifications(QList<QSharedPointer<NotificationDto>> newNotifications) {
+	m_notifications = newNotifications;
+}
 qint32 NotificationResultDto::totalRecordCount() const { return m_totalRecordCount; }
+
 void NotificationResultDto::setTotalRecordCount(qint32 newTotalRecordCount) {
 	m_totalRecordCount = newTotalRecordCount;
-	emit totalRecordCountChanged(newTotalRecordCount);
 }