Update outdated PlaybackState enums in QML

With the refractor in f91e9f8, an abstraction over QtMultiMedia was
implemented. New enums for the PlaybackState were created, to not make
the application depend on QtMultiMedia. However, not all code was
updated to make proper use of these new enums.

This in turn caused the screen turned off while playing a video and the
HUD not showing when the video started buffering. This commit fixes
that.

Closes #51

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: heartfin # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/doxygen.yaml

@@ -0,0 +1,40 @@
+name: doxygen
+run-name: Generate and deploy Doxygen documentation
+on: 
+  push:
+    branches:
+      - "master"
+  workflow_dispatch: {}
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Configure pages
+        uses: actions/configure-pages@v3
+      - name: Install the doxyqml filter
+        run: pip install doxyqml
+      - name: Doxygen
+        uses: mattnotmitt/doxygen-action@edge
+      - name: Upload GitHub pages artifact
+        uses: "actions/upload-pages-artifact@v2"
+        with:
+          path: "doxygen/html/"
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: "actions/deploy-pages@v2"

.gitignore

@@ -5,7 +5,9 @@ rpm/*.spec
 build/
 build-*/
 .dub/
+doxygen/
 
 # IDE files
 *.user
 CMakeLists.txt.user.*
+compile_commands.json

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "core/doc/doxygen-awesome-css"]
+	path = core/doc/doxygen-awesome-css
+	url = https://github.com/jothepro/doxygen-awesome-css.git
+[submodule "3rdparty/doxygen-awesome-css"]
+	path = 3rdparty/doxygen-awesome-css
+	url = https://github.com/jothepro/doxygen-awesome-css.git

3rdparty/doxygen-awesome-css

@@ -0,0 +1 @@
+Subproject commit 5b27b3a747ca1e559fa54149762cca0bad6036fb

README.md

@@ -1,8 +1,51 @@
 # Sailfin
+[!["Chat via Matrix"](https://img.shields.io/matrix/sailfin:netsoj.nl?label=Chat%20via%20Matrix&logo=matrix&server_fqdn=meetriks.netsoj.nl&style=for-the-badge)](https://matrix.to/#/#sailfin:netsoj.nl)  
 Sailfin is a [Sailfish OS](https://sailfishos.org) client for [Jellyfin](https://jellyfin.org), a media server, written in C++ and qml.
 
+## Download
+This application can be found on [OpenRepos.net](https://openrepos.net/content/ahappyhuman/sailfin)
+
 ## Screenshots (running on Sailfish OS)
-<img alt="Screenshot showing the library root" src="graphics/screenshot-sailfish-1.png" width="33%" /> <img alt="Screenshot showing TV show page" src="graphics/screenshot-sailfish-2.png" width="33%" /> <img alt="Screenshot showing the video player" src="graphics/screenshot-sailfish-3.png" width="33%" />
+<img alt="Screenshot showing the library root" src="graphics/screenshot-sailfish-1.png" width="33%" /> <img alt="Screenshot showing TV show page" src="graphics/screenshot-sailfish-2.png" width="33%" />
+
+## Contributing
+Please [see this page for how the Jellyfin Qt library works](https://heartfin.github.io/harbour-sailfin/guides.html).
+and [see this page for contribution guidelines](https://heartfin.github.io/harbour-sailfin/contributing.html).
+
+## Code layout
+```
+├── 3rdparty               3rd-party libraries
+├── cmake                  Additional CMake modules
+│
+├── core                   The core Qt library named Jellyfin-Qt
+│   ├── codegen            Template files for code generation based on the OpenAPI spec
+│   ├── dbus               DBus interface description files
+│   ├── doc                Extra documentation files for the generated documentation
+│   ├── include            Publically includable files
+│   ├── qrc                Resources for the library
+│   └── src                C++ source code
+│
+├── graphics               Source graphics files, meant to be edited
+│   └── qtquick-theme      Custom graphics for the QtQuick theme 
+│
+├── qtquick                QtQuick application for testing, based on the core library
+│   ├── assets             Custom assets
+│   ├── qml                QML UI files
+│   ├── SailfinStyle       QtQuick theme files
+│   └── src                C++ code
+│
+├── rpm                    Files for packaging the application
+│
+└── sailfish               The Sailfish OS app based on the core library
+    ├── icons              Launcher icons
+    ├── qml                QML UI files
+    │   ├── components     Reusable QML components
+    │   ├── cover          Cover pages
+    │   ├── licenses       Licence texts for libraries
+    │   └── pages          Application pages
+    ├── src                C++ source code
+    └── translations       UI translation files
+```
 
 ## License
 This application is licensed under the LGPLv2.1 license, although you may opt to choose a newer version of the LGPL if you want so.

core/CMakeLists.txt

@@ -13,9 +13,14 @@ include(GNUInstallDirs)
 include(GeneratedSources.cmake)
 
 set(JellyfinQt_SOURCES
+        src/model/controllablesession.cpp
         src/model/deviceprofile.cpp
         src/model/item.cpp
+        src/model/player.cpp
+        src/model/playbackmanager.cpp
+        src/model/playbackreporter.cpp
         src/model/playlist.cpp
+        src/model/remotejellyfinplayback.cpp
         src/model/shuffle.cpp
         src/model/user.cpp
 
@@ -29,6 +34,7 @@ set(JellyfinQt_SOURCES
         src/viewmodel/modelstatus.cpp
         src/viewmodel/playbackmanager.cpp
         src/viewmodel/playlist.cpp
+        src/viewmodel/remotedevice.cpp
         src/viewmodel/settings.cpp
         src/viewmodel/userdata.cpp
         src/viewmodel/usermodel.cpp
@@ -46,37 +52,44 @@ set(JellyfinQt_SOURCES
 list(APPEND JellyfinQt_SOURCES ${openapi_SOURCES})
 
 set(JellyfinQt_HEADERS
-        include/JellyfinQt/model/deviceprofile.h
-        include/JellyfinQt/model/item.h
-        include/JellyfinQt/model/playlist.h
-        include/JellyfinQt/model/shuffle.h
-        include/JellyfinQt/model/user.h
-        include/JellyfinQt/support/jsonconv.h
-        include/JellyfinQt/support/jsonconvimpl.h
-        include/JellyfinQt/support/loader.h
-        include/JellyfinQt/support/parseexception.h
-        include/JellyfinQt/viewmodel/item.h
-        include/JellyfinQt/viewmodel/itemmodel.h
-        include/JellyfinQt/viewmodel/loader.h
-        include/JellyfinQt/viewmodel/mediastream.h
-        include/JellyfinQt/viewmodel/modelstatus.h
-        include/JellyfinQt/viewmodel/propertyhelper.h
-        include/JellyfinQt/viewmodel/playbackmanager.h
-        include/JellyfinQt/viewmodel/platformmediacontrol.h
-        include/JellyfinQt/viewmodel/playlist.h
-        include/JellyfinQt/viewmodel/settings.h
-        include/JellyfinQt/viewmodel/userdata.h
-        include/JellyfinQt/viewmodel/usermodel.h
-        include/JellyfinQt/viewmodel/user.h
-        include/JellyfinQt/apiclient.h
-        include/JellyfinQt/apimodel.h
-        include/JellyfinQt/credentialmanager.h
-        include/JellyfinQt/eventbus.h
-        include/JellyfinQt/jellyfin.h
-        include/JellyfinQt/jsonhelper.h
-        include/JellyfinQt/qobjectsettingswrapper.h
-        include/JellyfinQt/serverdiscoverymodel.h
-        include/JellyfinQt/websocket.h)
+    include/JellyfinQt/model/controllablesession.h
+    include/JellyfinQt/model/deviceprofile.h
+    include/JellyfinQt/model/item.h
+    include/JellyfinQt/model/player.h
+    include/JellyfinQt/model/playbackmanager.h
+    include/JellyfinQt/model/playbackreporter.h
+    include/JellyfinQt/model/playlist.h
+    include/JellyfinQt/model/remotejellyfinplayback.h
+    include/JellyfinQt/model/shuffle.h
+    include/JellyfinQt/model/user.h
+    include/JellyfinQt/support/jsonconv.h
+    include/JellyfinQt/support/jsonconvimpl.h
+    include/JellyfinQt/support/loader.h
+    include/JellyfinQt/support/parseexception.h
+    include/JellyfinQt/viewmodel/item.h
+    include/JellyfinQt/viewmodel/itemmodel.h
+    include/JellyfinQt/viewmodel/loader.h
+    include/JellyfinQt/viewmodel/mediastream.h
+    include/JellyfinQt/viewmodel/modelstatus.h
+    include/JellyfinQt/viewmodel/propertyhelper.h
+    include/JellyfinQt/viewmodel/playbackmanager.h
+    include/JellyfinQt/viewmodel/platformmediacontrol.h
+    include/JellyfinQt/viewmodel/playlist.h
+    include/JellyfinQt/viewmodel/remotedevice.h
+    include/JellyfinQt/viewmodel/settings.h
+    include/JellyfinQt/viewmodel/userdata.h
+    include/JellyfinQt/viewmodel/usermodel.h
+    include/JellyfinQt/viewmodel/user.h
+    include/JellyfinQt/viewmodel/utils.h
+    include/JellyfinQt/apiclient.h
+    include/JellyfinQt/apimodel.h
+    include/JellyfinQt/credentialmanager.h
+    include/JellyfinQt/eventbus.h
+    include/JellyfinQt/jellyfin.h
+    include/JellyfinQt/jsonhelper.h
+    include/JellyfinQt/qobjectsettingswrapper.h
+    include/JellyfinQt/serverdiscoverymodel.h
+    include/JellyfinQt/websocket.h)
 
 if (FREEDESKTOP_INTEGRATION)
     list(APPEND JellyfinQt_SOURCES

core/doc/contributing.md

@@ -0,0 +1,77 @@
+\page contributing Contributing
+\brief All resources for (potential) contributors
+
+This page should contain all resources for people who'd like to contribute to the project. 
+If that happens to be you, thank you for considering to contribute to this project! 
+This page will describe how the process goes, what code style this project uses and more useful information.
+
+# Development process
+Development happens at [GitHub](https://github.com/heartfin/harbour-sailfin). 
+Currently, both the library Jellyfin-Qt and the [Sailfish OS](https://sailfishos.org) app named Sailfin are developed in the same repository.
+
+## Create or find an issue to work on
+If you want to contribute code, please check if an issue exists. 
+Otherwise, create an issue describing what feature you'd like to develop before creating a merge request.
+
+## Start working on your code
+Clone the git repo and create a new branch. 
+If you have commit access to the repository, please create a branch in the form of `<issue-number>-<issue-title>`. 
+For example, `36-control-remote-jellyfin-sessions`.
+
+Now you can start writing your code and create commits. 
+Please create focussed commits, that is, do not commit anything not related to the issue you are working on.
+Also state what you're changing in the commit message and add an entry in the file `rpm/harbour-sailfin.changes`.
+
+If this is your first time contributing to the project, don't be shy and feel free to add your name to the contributors list in `sailfish/qml/pages/AboutPage.qml`!
+
+## Submit a merge request
+Now that you have finalised your commit, you can create a merge request on the repository.
+Make sure that you have followed the contribution guidelines on this page.
+Someone will review it and if all is good, they will merge it in.
+
+Congratulations on your contribution!
+
+# Code style guidelines
+The code should follow the [Sailfish OS Code Conventions](https://docs.sailfishos.org/Develop/Apps/Coding_Conventions/) with the following exceptions:
+
+## Exceptions for C++
+- Put curly braces on the same line as the declaration, example:
+  ```cpp
+  int foo() {
+      // implementation
+  }
+  ```
+  instead of
+  ```cpp
+  int foo()
+  {
+     // implementation
+  }
+  ```
+  Rationale: I hate pressing enter and am used to the former. Moreover, it is already all over the place. Bad rationale, I know.
+
+- Close namespace brackets with a comment in the form `// NS Jellyfin`, example:
+  ```cpp
+  namespace Jellyfin {
+  namespace Nested {
+      // Content
+  } // NS Nested
+  } // NS Jellyfin
+  ```
+  Rationale: Easy to know what namespace the bracket closes, since namespaces tend to span over large portions of a file.
+
+- Use include guards in the form of `NAMESPACE_CLASSNAME_H`. Example:
+  ```cpp
+  #ifndef JELLYFIN_MODEL_USER_H
+  #define JELLYFIN_MODEL_USER_H
+  namespace Jellyfin {
+  namespace Model {
+
+  class User {
+      // Methods etc
+  };
+
+  } // NS Model
+  } // NS Jellyfin
+  ```
+

core/doc/custom.css

@@ -0,0 +1,15 @@
+html {
+		--primary-color: #be48d6;
+		--primary-dark-color: #7a2e89;
+		--primary-light-color #e256ff;
+}
+
+@media (prefers-color-scheme: dark) {
+    html:not(.light-mode) {
+		--primary-color: #be48d6;
+		--primary-dark-color: #7a2e89;
+		--primary-light-color #e256ff;
+    }
+}
+
+

core/doc/guide/apimodel-loader.md

@@ -0,0 +1,5 @@
+\page guide-apimodel-loader ApiModel and Loaders
+\brief This will give an overview of how the ApiModel and Loaders interact.
+
+\todo
+This guide should still be written

core/doc/guide/getting-started.md

@@ -0,0 +1,73 @@
+\page guide-getting-started Getting Started
+\brief Installation procedure and first application using this library
+
+This is a tutorial on how to use Jellyfin Qt library.
+
+## Project setup
+
+The library works as [a QML plugin](https://doc.qt.io/archives/qt-5.6/qqmlextensionplugin.html). 
+Compile the library, install it in the QML plugin path and add a qmldir file like this:
+
+```
+module nl.netsoj.chris.Jellyfin
+plugin JellyfinQt
+```
+
+You should then be able to import it in your QML files.
+
+
+```qml
+import nl.netsoj.chris.Jellyfin
+```
+
+\note
+In the documentation, the URI nl.netsoj.chris.Jellyfin will be used. 
+If you deviate from this, make sure to put the plugin in the correct location,
+as well as using the correct import statements in QML.
+
+## Hello Jellyfin!
+
+The first step for interacting with the library is setting up an \ref Jellyfin::ApiClient. 
+This object handles authentication. 
+
+
+
+\warning
+The way authentication works using ApiClient will change before the next major release to support multiple accounts! See \issue{4}
+
+Lets create an instance of ApiClient that is reachable from everywhere, by putting it in the ApplicationWindow:
+
+```qml
+import nl.netsoj.chris.Jellyfin as JF
+import QtQuick 2.0 as QQ
+
+QQ.ApplicationWindow {
+    readonly property JF.ApiClient apiClient: _apiClient
+
+    JF.ApiClient {
+        id: _apiClient
+        appName: "The name of your client"
+    }
+}
+```
+
+\note
+As an alternative, you could create a QML file only containing the ApiClient and [declaring it as a Singleton](https://doc.qt.io/archives/qt-5.6/qtqml-modules-qmldir.html#contents-of-a-module-definition-qmldir-file)
+
+## Authentication
+If the user already has logged in and the credentials are stored, this is quite easy: 
+the \ref Jellyfin::ApiClient::authenticated "authenticated" property will change to true and the corresponding signal will fire.
+You don't have to do anything else!
+
+When the user never has logged in, the signal \ref Jellyfin::ApiClient::setupRequired "setupRequired()" will be fired.
+When this happens, you should let the user enter a server URL and set it as the \ref Jellyfin::ApiClient::baseUrl "baseUrl" property.
+You can get a list model of servers in the local network using the \ref Jellyfin::ServerDiscoveryModel.
+
+After the \ref Jellyfin::ApiClient::baseUrl "baseUrl" property has been set, the slot \ref Jellyfin::ApiClient::authenticate "authenticate" should be called with an username and password.
+When authentication was successful, the property \ref Jellyfin::ApiClient::authenticated "authenticated" will be changed to true. 
+Otherwise, the signal \ref Jellyfin::ApiClient::authenticationError "authenticationError" will be fired.
+
+\note
+To show a list of available users, one can use the \ref Jellyfin::ViewModel::UserModel "UserModel" and \ref Jellyfin::ViewModel::PublicUsersLoader "PublicUsersLoader".
+However, this requires knowledge of the Loader and Model system, which will be explained in the next chapter \ref guide-apimodel-loader
+

core/doc/guides.md

@@ -0,0 +1,10 @@
+\page guides Usage guides
+
+\brief All guides intended for developers working with this library.
+
+All guides assume familiarity with QML. If you aren't, [the free online QML book](https://www.qt.io/product/qt6/qml-book) is a great place to start.
+Note that this book is written for Qt 6 QML, while this project is using Qt 5 QML.
+The differences between those versions are not large, so it still is a valuable resource.
+
+* \subpage guide-getting-started
+* \subpage guide-apimodel-loader

core/doc/mainpage.md

@@ -0,0 +1,11 @@
+\mainpage
+
+\note 
+This page is aimed at developers. If you are interested in using a Jellyfin application, please visit the [main website](https://heartfin.github.io/).
+
+This is the documentation page for the Jellyfin Qt library, a library for the [Qt framework](https://qt.io/) for interacting with the [Jellyfin media server](https://jellyfin.org).
+This project is not affiliated with the Jellyfin project.
+
+If you are planning on using this projects, see \ref guides for usage instructions and the reference documentation in the sidebar.
+
+If you'd like to contribute code, see \ref contributing for the process and style guidelines.

core/doc/namespace/dto.dox

@@ -0,0 +1,4 @@
+/**
+ * \namespace Jellyfin::DTO
+ * \brief Contains auto-generated Data Transfer Objects for the Jellyfin HTTP API
+ */

core/doc/namespace/viewmodel.dox

@@ -0,0 +1,4 @@
+/**
+ * \namespace Jellyfin::ViewModel
+ * \brief Contains all types exposed to QML
+ */

core/include/JellyfinQt/apiclient.h

@@ -41,6 +41,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "dto/generalcommandtype.h"
 #include "credentialmanager.h"
+#include "model/controllablesession.h"
 #include "model/deviceprofile.h"
 #include "eventbus.h"
 
@@ -96,6 +97,8 @@ public:
     explicit ApiClient(QObject *parent = nullptr);
     virtual ~ApiClient();
     Q_PROPERTY(QString baseUrl READ baseUrl WRITE setBaseUrl NOTIFY baseUrlChanged)
+    Q_PROPERTY(QString appName READ appName WRITE setAppName NOTIFY appNameChanged)
+    Q_PROPERTY(Jellyfin::Model::DeviceTypeClass::Value deviceType READ deviceType WRITE setDeviceType NOTIFY deviceTypeChanged)
     Q_PROPERTY(bool authenticated READ authenticated WRITE setAuthenticated NOTIFY authenticatedChanged)
     Q_PROPERTY(QString userId READ userId NOTIFY userIdChanged)
     Q_PROPERTY(QJsonObject deviceProfile READ deviceProfileJson NOTIFY deviceProfileChanged)
@@ -114,6 +117,9 @@ public:
 
     bool authenticated() const;
     void setBaseUrl(const QString &url);
+    void setAppName(const QString &appName);
+    void setDeviceType(Model::DeviceType deviceType);
+
     QNetworkReply *get(const QString &path, const QUrlQuery &params = QUrlQuery());
     QNetworkReply *post(const QString &path, const QJsonDocument &data, const QUrlQuery &params = QUrlQuery());
     QNetworkReply *post(const QString &path, const QByteArray &data = QByteArray(), const QUrlQuery &params = QUrlQuery());
@@ -127,8 +133,10 @@ public:
     Q_ENUM(ApiError)
 
     const QString &baseUrl() const;
+    const QString &appName() const;
     const QString &userId() const;
     const QString &deviceId() const;
+    Model::DeviceType deviceType() const;
     /**
      * @brief QML applications can set this type to indicate which commands they support.
      *
@@ -185,6 +193,7 @@ signals:
 
     void authenticatedChanged(bool authenticated);
     void baseUrlChanged(const QString &baseUrl);
+    void appNameChanged(const QString &newAppName);
     void settingsChanged();
 
     /**
@@ -196,9 +205,18 @@ signals:
     void userIdChanged(QString userId);
 
     void deviceProfileChanged();
+    void deviceTypeChanged();
 
     void supportedCommandsChanged();
     void onlineChanged();
+    /**
+     * @brief Emitted after submitQuickConnectCode succeeded
+     */
+    void quickConnectAccepted();
+    /**
+     * @brief Emitted after submitQuickConnectCode failed
+     */
+    void quickConnectRejected();
 
     /**
      * @brief onUserDataChanged Emitted when the user data of an item is changed on the server.
@@ -223,6 +241,7 @@ public slots:
      */
     void setupConnection();
     void authenticate(QString username, QString password, bool storeCredentials = false);
+    void submitQuickConnectCode(const QString &code);
 
     /**
      * @brief Logs the user out and clears the session.

core/include/JellyfinQt/apimodel.h

@@ -251,6 +251,10 @@ extern template void setRequestLimit(Loader::GetResumeItemsParams &params, int l
 extern template bool setRequestStartIndex(Loader::GetResumeItemsParams &params, int offset);
 extern template void setRequestLimit(Loader::GetPublicUsersParams &params, int limit);
 extern template bool setRequestStartIndex(Loader::GetPublicUsersParams &params, int offset);
+extern template void setRequestLimit(Loader::GetNextUpParams &params, int limit);
+extern template bool setRequestStartIndex(Loader::GetNextUpParams &params, int offset);
+extern template void setRequestLimit(Loader::GetAlbumArtistsParams &params, int limit);
+extern template bool setRequestStartIndex(Loader::GetAlbumArtistsParams &params, int offset);
 
 extern template QList<DTO::UserDto> extractRecords(const QList<DTO::UserDto> &result);
 extern template int extractTotalRecordCount(const QList<DTO::UserDto> &result);
@@ -485,6 +489,10 @@ public:
         this->endResetModel();
     }
 
+    const QList<QSharedPointer<T>> &toList() {
+        return m_array;
+    }
+
     // From AbstractListModel, gets implemented in ApiModel<T>
     //virtual QHash<int, QByteArray> roleNames() const override = 0;
     /*virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override = 0;*/

core/include/JellyfinQt/eventbus.h

@@ -26,6 +26,7 @@ namespace Jellyfin {
 namespace DTO {
     class UserItemDataDto;
     class PlaystateRequest;
+    class SessionInfo;
 }
 
 /**
@@ -44,6 +45,13 @@ signals:
      */
     void itemUserDataUpdated(const QString &itemId, const DTO::UserItemDataDto &userData);
 
+    /**
+     * @brief The information about a session has been updated
+     * @param sessionId The id of the session
+     * @param sessionInfo The associated information
+     */
+    void sessionInfoUpdated(const QString &sessionId, const DTO::SessionInfo &sessionInfo);
+
     /**
      * @brief The server has requested to display an message to the user
      * @param header The header of the message.

core/include/JellyfinQt/loader/http/apikey.h

@@ -61,6 +61,34 @@ protected:
 	QByteArray body(const GetKeysParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Create a new api key.
+ */
+
+class CreateKeyLoader : public Jellyfin::Support::HttpLoader<void, CreateKeyParams> {
+public:
+	explicit CreateKeyLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CreateKeyParams& parameters) const override;
+	QUrlQuery query(const CreateKeyParams& parameters) const override;
+	QByteArray body(const CreateKeyParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Remove an api key.
+ */
+
+class RevokeKeyLoader : public Jellyfin::Support::HttpLoader<void, RevokeKeyParams> {
+public:
+	explicit RevokeKeyLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RevokeKeyParams& parameters) const override;
+	QUrlQuery query(const RevokeKeyParams& parameters) const override;
+	QByteArray body(const RevokeKeyParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/branding.h

@@ -65,7 +65,7 @@ protected:
  * @brief Gets branding css.
  */
 
-class GetBrandingCssLoader : public Jellyfin::Support::HttpLoader<QString, GetBrandingCssParams> {
+class GetBrandingCssLoader : public Jellyfin::Support::HttpLoader<void, GetBrandingCssParams> {
 public:
 	explicit GetBrandingCssLoader(ApiClient *apiClient = nullptr);
 
@@ -79,7 +79,7 @@ protected:
  * @brief Gets branding css.
  */
 
-class GetBrandingCss_2Loader : public Jellyfin::Support::HttpLoader<QString, GetBrandingCss_2Params> {
+class GetBrandingCss_2Loader : public Jellyfin::Support::HttpLoader<void, GetBrandingCss_2Params> {
 public:
 	explicit GetBrandingCss_2Loader(ApiClient *apiClient = nullptr);
 

core/include/JellyfinQt/loader/http/collection.h

@@ -61,6 +61,34 @@ protected:
 	QByteArray body(const CreateCollectionParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Adds items to a collection.
+ */
+
+class AddToCollectionLoader : public Jellyfin::Support::HttpLoader<void, AddToCollectionParams> {
+public:
+	explicit AddToCollectionLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const AddToCollectionParams& parameters) const override;
+	QUrlQuery query(const AddToCollectionParams& parameters) const override;
+	QByteArray body(const AddToCollectionParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Removes items from a collection.
+ */
+
+class RemoveFromCollectionLoader : public Jellyfin::Support::HttpLoader<void, RemoveFromCollectionParams> {
+public:
+	explicit RemoveFromCollectionLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RemoveFromCollectionParams& parameters) const override;
+	QUrlQuery query(const RemoveFromCollectionParams& parameters) const override;
+	QByteArray body(const RemoveFromCollectionParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/configuration.h

@@ -62,6 +62,20 @@ protected:
 	QByteArray body(const GetConfigurationParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Updates application configuration.
+ */
+
+class UpdateConfigurationLoader : public Jellyfin::Support::HttpLoader<void, UpdateConfigurationParams> {
+public:
+	explicit UpdateConfigurationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateConfigurationParams& parameters) const override;
+	QUrlQuery query(const UpdateConfigurationParams& parameters) const override;
+	QByteArray body(const UpdateConfigurationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a named configuration.
  */
@@ -76,6 +90,20 @@ protected:
 	QByteArray body(const GetNamedConfigurationParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Updates named configuration.
+ */
+
+class UpdateNamedConfigurationLoader : public Jellyfin::Support::HttpLoader<void, UpdateNamedConfigurationParams> {
+public:
+	explicit UpdateNamedConfigurationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateNamedConfigurationParams& parameters) const override;
+	QUrlQuery query(const UpdateNamedConfigurationParams& parameters) const override;
+	QByteArray body(const UpdateNamedConfigurationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a default MetadataOptions object.
  */
@@ -90,6 +118,20 @@ protected:
 	QByteArray body(const GetDefaultMetadataOptionsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Updates the path to the media encoder.
+ */
+
+class UpdateMediaEncoderPathLoader : public Jellyfin::Support::HttpLoader<void, UpdateMediaEncoderPathParams> {
+public:
+	explicit UpdateMediaEncoderPathLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateMediaEncoderPathParams& parameters) const override;
+	QUrlQuery query(const UpdateMediaEncoderPathParams& parameters) const override;
+	QByteArray body(const UpdateMediaEncoderPathParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/devices.h

@@ -63,6 +63,20 @@ protected:
 	QByteArray body(const GetDevicesParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Deletes a device.
+ */
+
+class DeleteDeviceLoader : public Jellyfin::Support::HttpLoader<void, DeleteDeviceParams> {
+public:
+	explicit DeleteDeviceLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteDeviceParams& parameters) const override;
+	QUrlQuery query(const DeleteDeviceParams& parameters) const override;
+	QByteArray body(const DeleteDeviceParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Get info for a device.
  */
@@ -91,6 +105,20 @@ protected:
 	QByteArray body(const GetDeviceOptionsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Update device options.
+ */
+
+class UpdateDeviceOptionsLoader : public Jellyfin::Support::HttpLoader<void, UpdateDeviceOptionsParams> {
+public:
+	explicit UpdateDeviceOptionsLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateDeviceOptionsParams& parameters) const override;
+	QUrlQuery query(const UpdateDeviceOptionsParams& parameters) const override;
+	QByteArray body(const UpdateDeviceOptionsParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/displaypreferences.h

@@ -61,6 +61,20 @@ protected:
 	QByteArray body(const GetDisplayPreferencesParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Update Display Preferences.
+ */
+
+class UpdateDisplayPreferencesLoader : public Jellyfin::Support::HttpLoader<void, UpdateDisplayPreferencesParams> {
+public:
+	explicit UpdateDisplayPreferencesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateDisplayPreferencesParams& parameters) const override;
+	QUrlQuery query(const UpdateDisplayPreferencesParams& parameters) const override;
+	QByteArray body(const UpdateDisplayPreferencesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/dlna.h

@@ -63,6 +63,20 @@ protected:
 	QByteArray body(const GetProfileInfosParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Creates a profile.
+ */
+
+class CreateProfileLoader : public Jellyfin::Support::HttpLoader<void, CreateProfileParams> {
+public:
+	explicit CreateProfileLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CreateProfileParams& parameters) const override;
+	QUrlQuery query(const CreateProfileParams& parameters) const override;
+	QByteArray body(const CreateProfileParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a single profile.
  */
@@ -77,6 +91,34 @@ protected:
 	QByteArray body(const GetProfileParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Deletes a profile.
+ */
+
+class DeleteProfileLoader : public Jellyfin::Support::HttpLoader<void, DeleteProfileParams> {
+public:
+	explicit DeleteProfileLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteProfileParams& parameters) const override;
+	QUrlQuery query(const DeleteProfileParams& parameters) const override;
+	QByteArray body(const DeleteProfileParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a profile.
+ */
+
+class UpdateProfileLoader : public Jellyfin::Support::HttpLoader<void, UpdateProfileParams> {
+public:
+	explicit UpdateProfileLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateProfileParams& parameters) const override;
+	QUrlQuery query(const UpdateProfileParams& parameters) const override;
+	QByteArray body(const UpdateProfileParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the default profile.
  */

core/include/JellyfinQt/loader/http/environment.h

@@ -120,6 +120,20 @@ protected:
 	QByteArray body(const GetParentPathParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Validates path.
+ */
+
+class ValidatePathLoader : public Jellyfin::Support::HttpLoader<void, ValidatePathParams> {
+public:
+	explicit ValidatePathLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ValidatePathParams& parameters) const override;
+	QUrlQuery query(const ValidatePathParams& parameters) const override;
+	QByteArray body(const ValidatePathParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/hlssegment.h

@@ -46,6 +46,20 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Stops an active encoding.
+ */
+
+class StopEncodingProcessLoader : public Jellyfin::Support::HttpLoader<void, StopEncodingProcessParams> {
+public:
+	explicit StopEncodingProcessLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const StopEncodingProcessParams& parameters) const override;
+	QUrlQuery query(const StopEncodingProcessParams& parameters) const override;
+	QByteArray body(const StopEncodingProcessParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/image.h

@@ -61,6 +61,132 @@ protected:
 	QByteArray body(const GetItemImageInfosParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Delete an item's image.
+ */
+
+class DeleteItemImageLoader : public Jellyfin::Support::HttpLoader<void, DeleteItemImageParams> {
+public:
+	explicit DeleteItemImageLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteItemImageParams& parameters) const override;
+	QUrlQuery query(const DeleteItemImageParams& parameters) const override;
+	QByteArray body(const DeleteItemImageParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Set item image.
+ */
+
+class SetItemImageLoader : public Jellyfin::Support::HttpLoader<void, SetItemImageParams> {
+public:
+	explicit SetItemImageLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SetItemImageParams& parameters) const override;
+	QUrlQuery query(const SetItemImageParams& parameters) const override;
+	QByteArray body(const SetItemImageParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Delete an item's image.
+ */
+
+class DeleteItemImageByIndexLoader : public Jellyfin::Support::HttpLoader<void, DeleteItemImageByIndexParams> {
+public:
+	explicit DeleteItemImageByIndexLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteItemImageByIndexParams& parameters) const override;
+	QUrlQuery query(const DeleteItemImageByIndexParams& parameters) const override;
+	QByteArray body(const DeleteItemImageByIndexParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Set item image.
+ */
+
+class SetItemImageByIndexLoader : public Jellyfin::Support::HttpLoader<void, SetItemImageByIndexParams> {
+public:
+	explicit SetItemImageByIndexLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SetItemImageByIndexParams& parameters) const override;
+	QUrlQuery query(const SetItemImageByIndexParams& parameters) const override;
+	QByteArray body(const SetItemImageByIndexParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates the index for an item image.
+ */
+
+class UpdateItemImageIndexLoader : public Jellyfin::Support::HttpLoader<void, UpdateItemImageIndexParams> {
+public:
+	explicit UpdateItemImageIndexLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateItemImageIndexParams& parameters) const override;
+	QUrlQuery query(const UpdateItemImageIndexParams& parameters) const override;
+	QByteArray body(const UpdateItemImageIndexParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Sets the user image.
+ */
+
+class PostUserImageLoader : public Jellyfin::Support::HttpLoader<void, PostUserImageParams> {
+public:
+	explicit PostUserImageLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostUserImageParams& parameters) const override;
+	QUrlQuery query(const PostUserImageParams& parameters) const override;
+	QByteArray body(const PostUserImageParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Delete the user's image.
+ */
+
+class DeleteUserImageLoader : public Jellyfin::Support::HttpLoader<void, DeleteUserImageParams> {
+public:
+	explicit DeleteUserImageLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteUserImageParams& parameters) const override;
+	QUrlQuery query(const DeleteUserImageParams& parameters) const override;
+	QByteArray body(const DeleteUserImageParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Sets the user image.
+ */
+
+class PostUserImageByIndexLoader : public Jellyfin::Support::HttpLoader<void, PostUserImageByIndexParams> {
+public:
+	explicit PostUserImageByIndexLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostUserImageByIndexParams& parameters) const override;
+	QUrlQuery query(const PostUserImageByIndexParams& parameters) const override;
+	QByteArray body(const PostUserImageByIndexParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Delete the user's image.
+ */
+
+class DeleteUserImageByIndexLoader : public Jellyfin::Support::HttpLoader<void, DeleteUserImageByIndexParams> {
+public:
+	explicit DeleteUserImageByIndexLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteUserImageByIndexParams& parameters) const override;
+	QUrlQuery query(const DeleteUserImageByIndexParams& parameters) const override;
+	QByteArray body(const DeleteUserImageByIndexParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/itemlookup.h

@@ -70,6 +70,20 @@ protected:
 	QByteArray body(const GetExternalIdInfosParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Applies search criteria to an item and refreshes metadata.
+ */
+
+class ApplySearchCriteriaLoader : public Jellyfin::Support::HttpLoader<void, ApplySearchCriteriaParams> {
+public:
+	explicit ApplySearchCriteriaLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ApplySearchCriteriaParams& parameters) const override;
+	QUrlQuery query(const ApplySearchCriteriaParams& parameters) const override;
+	QByteArray body(const ApplySearchCriteriaParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Get book remote search.
  */

core/include/JellyfinQt/loader/http/itemrefresh.h

@@ -46,6 +46,20 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Refreshes metadata for an item.
+ */
+
+class PostLoader : public Jellyfin::Support::HttpLoader<void, PostParams> {
+public:
+	explicit PostLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostParams& parameters) const override;
+	QUrlQuery query(const PostParams& parameters) const override;
+	QByteArray body(const PostParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/itemupdate.h

@@ -47,6 +47,34 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Updates an item.
+ */
+
+class UpdateItemLoader : public Jellyfin::Support::HttpLoader<void, UpdateItemParams> {
+public:
+	explicit UpdateItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateItemParams& parameters) const override;
+	QUrlQuery query(const UpdateItemParams& parameters) const override;
+	QByteArray body(const UpdateItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates an item's content type.
+ */
+
+class UpdateItemContentTypeLoader : public Jellyfin::Support::HttpLoader<void, UpdateItemContentTypeParams> {
+public:
+	explicit UpdateItemContentTypeLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateItemContentTypeParams& parameters) const override;
+	QUrlQuery query(const UpdateItemContentTypeParams& parameters) const override;
+	QByteArray body(const UpdateItemContentTypeParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets metadata editor info for an item.
  */

core/include/JellyfinQt/loader/http/library.h

@@ -61,6 +61,34 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Deletes items from the library and filesystem.
+ */
+
+class DeleteItemsLoader : public Jellyfin::Support::HttpLoader<void, DeleteItemsParams> {
+public:
+	explicit DeleteItemsLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteItemsParams& parameters) const override;
+	QUrlQuery query(const DeleteItemsParams& parameters) const override;
+	QByteArray body(const DeleteItemsParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Deletes an item from the library and filesystem.
+ */
+
+class DeleteItemLoader : public Jellyfin::Support::HttpLoader<void, DeleteItemParams> {
+public:
+	explicit DeleteItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteItemParams& parameters) const override;
+	QUrlQuery query(const DeleteItemParams& parameters) const override;
+	QByteArray body(const DeleteItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets similar items.
  */
@@ -201,6 +229,20 @@ protected:
 	QByteArray body(const GetLibraryOptionsInfoParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Reports that new movies have been added by an external source.
+ */
+
+class PostUpdatedMediaLoader : public Jellyfin::Support::HttpLoader<void, PostUpdatedMediaParams> {
+public:
+	explicit PostUpdatedMediaLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostUpdatedMediaParams& parameters) const override;
+	QUrlQuery query(const PostUpdatedMediaParams& parameters) const override;
+	QByteArray body(const PostUpdatedMediaParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets all user media folders.
  */
@@ -215,6 +257,34 @@ protected:
 	QByteArray body(const GetMediaFoldersParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Reports that new movies have been added by an external source.
+ */
+
+class PostAddedMoviesLoader : public Jellyfin::Support::HttpLoader<void, PostAddedMoviesParams> {
+public:
+	explicit PostAddedMoviesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostAddedMoviesParams& parameters) const override;
+	QUrlQuery query(const PostAddedMoviesParams& parameters) const override;
+	QByteArray body(const PostAddedMoviesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports that new movies have been added by an external source.
+ */
+
+class PostUpdatedMoviesLoader : public Jellyfin::Support::HttpLoader<void, PostUpdatedMoviesParams> {
+public:
+	explicit PostUpdatedMoviesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostUpdatedMoviesParams& parameters) const override;
+	QUrlQuery query(const PostUpdatedMoviesParams& parameters) const override;
+	QByteArray body(const PostUpdatedMoviesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a list of physical paths from virtual folders.
  */
@@ -229,6 +299,48 @@ protected:
 	QByteArray body(const GetPhysicalPathsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Starts a library scan.
+ */
+
+class RefreshLibraryLoader : public Jellyfin::Support::HttpLoader<void, RefreshLibraryParams> {
+public:
+	explicit RefreshLibraryLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RefreshLibraryParams& parameters) const override;
+	QUrlQuery query(const RefreshLibraryParams& parameters) const override;
+	QByteArray body(const RefreshLibraryParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports that new episodes of a series have been added by an external source.
+ */
+
+class PostAddedSeriesLoader : public Jellyfin::Support::HttpLoader<void, PostAddedSeriesParams> {
+public:
+	explicit PostAddedSeriesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostAddedSeriesParams& parameters) const override;
+	QUrlQuery query(const PostAddedSeriesParams& parameters) const override;
+	QByteArray body(const PostAddedSeriesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports that new episodes of a series have been added by an external source.
+ */
+
+class PostUpdatedSeriesLoader : public Jellyfin::Support::HttpLoader<void, PostUpdatedSeriesParams> {
+public:
+	explicit PostUpdatedSeriesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostUpdatedSeriesParams& parameters) const override;
+	QUrlQuery query(const PostUpdatedSeriesParams& parameters) const override;
+	QByteArray body(const PostUpdatedSeriesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets similar items.
  */

core/include/JellyfinQt/loader/http/librarystructure.h

@@ -61,6 +61,104 @@ protected:
 	QByteArray body(const GetVirtualFoldersParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Adds a virtual folder.
+ */
+
+class AddVirtualFolderLoader : public Jellyfin::Support::HttpLoader<void, AddVirtualFolderParams> {
+public:
+	explicit AddVirtualFolderLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const AddVirtualFolderParams& parameters) const override;
+	QUrlQuery query(const AddVirtualFolderParams& parameters) const override;
+	QByteArray body(const AddVirtualFolderParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Removes a virtual folder.
+ */
+
+class RemoveVirtualFolderLoader : public Jellyfin::Support::HttpLoader<void, RemoveVirtualFolderParams> {
+public:
+	explicit RemoveVirtualFolderLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RemoveVirtualFolderParams& parameters) const override;
+	QUrlQuery query(const RemoveVirtualFolderParams& parameters) const override;
+	QByteArray body(const RemoveVirtualFolderParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Update library options.
+ */
+
+class UpdateLibraryOptionsLoader : public Jellyfin::Support::HttpLoader<void, UpdateLibraryOptionsParams> {
+public:
+	explicit UpdateLibraryOptionsLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateLibraryOptionsParams& parameters) const override;
+	QUrlQuery query(const UpdateLibraryOptionsParams& parameters) const override;
+	QByteArray body(const UpdateLibraryOptionsParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Renames a virtual folder.
+ */
+
+class RenameVirtualFolderLoader : public Jellyfin::Support::HttpLoader<void, RenameVirtualFolderParams> {
+public:
+	explicit RenameVirtualFolderLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RenameVirtualFolderParams& parameters) const override;
+	QUrlQuery query(const RenameVirtualFolderParams& parameters) const override;
+	QByteArray body(const RenameVirtualFolderParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Add a media path to a library.
+ */
+
+class AddMediaPathLoader : public Jellyfin::Support::HttpLoader<void, AddMediaPathParams> {
+public:
+	explicit AddMediaPathLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const AddMediaPathParams& parameters) const override;
+	QUrlQuery query(const AddMediaPathParams& parameters) const override;
+	QByteArray body(const AddMediaPathParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Remove a media path.
+ */
+
+class RemoveMediaPathLoader : public Jellyfin::Support::HttpLoader<void, RemoveMediaPathParams> {
+public:
+	explicit RemoveMediaPathLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RemoveMediaPathParams& parameters) const override;
+	QUrlQuery query(const RemoveMediaPathParams& parameters) const override;
+	QByteArray body(const RemoveMediaPathParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a media path.
+ */
+
+class UpdateMediaPathLoader : public Jellyfin::Support::HttpLoader<void, UpdateMediaPathParams> {
+public:
+	explicit UpdateMediaPathLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateMediaPathParams& parameters) const override;
+	QUrlQuery query(const UpdateMediaPathParams& parameters) const override;
+	QByteArray body(const UpdateMediaPathParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/livetv.h

@@ -171,6 +171,20 @@ protected:
 	QByteArray body(const AddListingProviderParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Delete listing provider.
+ */
+
+class DeleteListingProviderLoader : public Jellyfin::Support::HttpLoader<void, DeleteListingProviderParams> {
+public:
+	explicit DeleteListingProviderLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteListingProviderParams& parameters) const override;
+	QUrlQuery query(const DeleteListingProviderParams& parameters) const override;
+	QByteArray body(const DeleteListingProviderParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets default listings provider info.
  */
@@ -297,6 +311,20 @@ protected:
 	QByteArray body(const GetRecordingParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Deletes a live tv recording.
+ */
+
+class DeleteRecordingLoader : public Jellyfin::Support::HttpLoader<void, DeleteRecordingParams> {
+public:
+	explicit DeleteRecordingLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteRecordingParams& parameters) const override;
+	QUrlQuery query(const DeleteRecordingParams& parameters) const override;
+	QByteArray body(const DeleteRecordingParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets recording folders.
  */
@@ -353,6 +381,20 @@ protected:
 	QByteArray body(const GetSeriesTimersParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Creates a live tv series timer.
+ */
+
+class CreateSeriesTimerLoader : public Jellyfin::Support::HttpLoader<void, CreateSeriesTimerParams> {
+public:
+	explicit CreateSeriesTimerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CreateSeriesTimerParams& parameters) const override;
+	QUrlQuery query(const CreateSeriesTimerParams& parameters) const override;
+	QByteArray body(const CreateSeriesTimerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a live tv series timer.
  */
@@ -367,6 +409,34 @@ protected:
 	QByteArray body(const GetSeriesTimerParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Cancels a live tv series timer.
+ */
+
+class CancelSeriesTimerLoader : public Jellyfin::Support::HttpLoader<void, CancelSeriesTimerParams> {
+public:
+	explicit CancelSeriesTimerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CancelSeriesTimerParams& parameters) const override;
+	QUrlQuery query(const CancelSeriesTimerParams& parameters) const override;
+	QByteArray body(const CancelSeriesTimerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a live tv series timer.
+ */
+
+class UpdateSeriesTimerLoader : public Jellyfin::Support::HttpLoader<void, UpdateSeriesTimerParams> {
+public:
+	explicit UpdateSeriesTimerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateSeriesTimerParams& parameters) const override;
+	QUrlQuery query(const UpdateSeriesTimerParams& parameters) const override;
+	QByteArray body(const UpdateSeriesTimerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the live tv timers.
  */
@@ -381,6 +451,20 @@ protected:
 	QByteArray body(const GetTimersParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Creates a live tv timer.
+ */
+
+class CreateTimerLoader : public Jellyfin::Support::HttpLoader<void, CreateTimerParams> {
+public:
+	explicit CreateTimerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CreateTimerParams& parameters) const override;
+	QUrlQuery query(const CreateTimerParams& parameters) const override;
+	QByteArray body(const CreateTimerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a timer.
  */
@@ -395,6 +479,34 @@ protected:
 	QByteArray body(const GetTimerParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Cancels a live tv timer.
+ */
+
+class CancelTimerLoader : public Jellyfin::Support::HttpLoader<void, CancelTimerParams> {
+public:
+	explicit CancelTimerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CancelTimerParams& parameters) const override;
+	QUrlQuery query(const CancelTimerParams& parameters) const override;
+	QByteArray body(const CancelTimerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a live tv timer.
+ */
+
+class UpdateTimerLoader : public Jellyfin::Support::HttpLoader<void, UpdateTimerParams> {
+public:
+	explicit UpdateTimerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateTimerParams& parameters) const override;
+	QUrlQuery query(const UpdateTimerParams& parameters) const override;
+	QByteArray body(const UpdateTimerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the default values for a new timer.
  */
@@ -423,6 +535,20 @@ protected:
 	QByteArray body(const AddTunerHostParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Deletes a tuner host.
+ */
+
+class DeleteTunerHostLoader : public Jellyfin::Support::HttpLoader<void, DeleteTunerHostParams> {
+public:
+	explicit DeleteTunerHostLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteTunerHostParams& parameters) const override;
+	QUrlQuery query(const DeleteTunerHostParams& parameters) const override;
+	QByteArray body(const DeleteTunerHostParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Get tuner host types.
  */
@@ -437,6 +563,20 @@ protected:
 	QByteArray body(const GetTunerHostTypesParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Resets a tv tuner.
+ */
+
+class ResetTunerLoader : public Jellyfin::Support::HttpLoader<void, ResetTunerParams> {
+public:
+	explicit ResetTunerLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ResetTunerParams& parameters) const override;
+	QUrlQuery query(const ResetTunerParams& parameters) const override;
+	QByteArray body(const ResetTunerParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Discover tuners.
  */

core/include/JellyfinQt/loader/http/mediainfo.h

@@ -77,6 +77,20 @@ protected:
 	QByteArray body(const GetPostedPlaybackInfoParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Closes a media source.
+ */
+
+class CloseLiveStreamLoader : public Jellyfin::Support::HttpLoader<void, CloseLiveStreamParams> {
+public:
+	explicit CloseLiveStreamLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CloseLiveStreamParams& parameters) const override;
+	QUrlQuery query(const CloseLiveStreamParams& parameters) const override;
+	QByteArray body(const CloseLiveStreamParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Opens a media source.
  */

core/include/JellyfinQt/loader/http/notifications.h

@@ -64,6 +64,20 @@ protected:
 	QByteArray body(const GetNotificationsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Sets notifications as read.
+ */
+
+class SetReadLoader : public Jellyfin::Support::HttpLoader<void, SetReadParams> {
+public:
+	explicit SetReadLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SetReadParams& parameters) const override;
+	QUrlQuery query(const SetReadParams& parameters) const override;
+	QByteArray body(const SetReadParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets a user's notification summary.
  */
@@ -78,6 +92,34 @@ protected:
 	QByteArray body(const GetNotificationsSummaryParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Sets notifications as unread.
+ */
+
+class SetUnreadLoader : public Jellyfin::Support::HttpLoader<void, SetUnreadParams> {
+public:
+	explicit SetUnreadLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SetUnreadParams& parameters) const override;
+	QUrlQuery query(const SetUnreadParams& parameters) const override;
+	QByteArray body(const SetUnreadParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Sends a notification to all admins.
+ */
+
+class CreateAdminNotificationLoader : public Jellyfin::Support::HttpLoader<void, CreateAdminNotificationParams> {
+public:
+	explicit CreateAdminNotificationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CreateAdminNotificationParams& parameters) const override;
+	QUrlQuery query(const CreateAdminNotificationParams& parameters) const override;
+	QByteArray body(const CreateAdminNotificationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets notification services.
  */

core/include/JellyfinQt/loader/http/package.h

@@ -77,6 +77,34 @@ protected:
 	QByteArray body(const GetPackageInfoParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Installs a package.
+ */
+
+class InstallPackageLoader : public Jellyfin::Support::HttpLoader<void, InstallPackageParams> {
+public:
+	explicit InstallPackageLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const InstallPackageParams& parameters) const override;
+	QUrlQuery query(const InstallPackageParams& parameters) const override;
+	QByteArray body(const InstallPackageParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Cancels a package installation.
+ */
+
+class CancelPackageInstallationLoader : public Jellyfin::Support::HttpLoader<void, CancelPackageInstallationParams> {
+public:
+	explicit CancelPackageInstallationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CancelPackageInstallationParams& parameters) const override;
+	QUrlQuery query(const CancelPackageInstallationParams& parameters) const override;
+	QByteArray body(const CancelPackageInstallationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets all package repositories.
  */
@@ -91,6 +119,20 @@ protected:
 	QByteArray body(const GetRepositoriesParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Sets the enabled and existing package repositories.
+ */
+
+class SetRepositoriesLoader : public Jellyfin::Support::HttpLoader<void, SetRepositoriesParams> {
+public:
+	explicit SetRepositoriesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SetRepositoriesParams& parameters) const override;
+	QUrlQuery query(const SetRepositoriesParams& parameters) const override;
+	QByteArray body(const SetRepositoriesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/playlists.h

@@ -62,6 +62,34 @@ protected:
 	QByteArray body(const CreatePlaylistParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Adds items to a playlist.
+ */
+
+class AddToPlaylistLoader : public Jellyfin::Support::HttpLoader<void, AddToPlaylistParams> {
+public:
+	explicit AddToPlaylistLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const AddToPlaylistParams& parameters) const override;
+	QUrlQuery query(const AddToPlaylistParams& parameters) const override;
+	QByteArray body(const AddToPlaylistParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Removes items from a playlist.
+ */
+
+class RemoveFromPlaylistLoader : public Jellyfin::Support::HttpLoader<void, RemoveFromPlaylistParams> {
+public:
+	explicit RemoveFromPlaylistLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RemoveFromPlaylistParams& parameters) const override;
+	QUrlQuery query(const RemoveFromPlaylistParams& parameters) const override;
+	QByteArray body(const RemoveFromPlaylistParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the original items of a playlist.
  */
@@ -76,6 +104,20 @@ protected:
 	QByteArray body(const GetPlaylistItemsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Moves a playlist item.
+ */
+
+class MoveItemLoader : public Jellyfin::Support::HttpLoader<void, MoveItemParams> {
+public:
+	explicit MoveItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const MoveItemParams& parameters) const override;
+	QUrlQuery query(const MoveItemParams& parameters) const override;
+	QByteArray body(const MoveItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/playstate.h

@@ -48,6 +48,62 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Reports playback has started within a session.
+ */
+
+class ReportPlaybackStartLoader : public Jellyfin::Support::HttpLoader<void, ReportPlaybackStartParams> {
+public:
+	explicit ReportPlaybackStartLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ReportPlaybackStartParams& parameters) const override;
+	QUrlQuery query(const ReportPlaybackStartParams& parameters) const override;
+	QByteArray body(const ReportPlaybackStartParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Pings a playback session.
+ */
+
+class PingPlaybackSessionLoader : public Jellyfin::Support::HttpLoader<void, PingPlaybackSessionParams> {
+public:
+	explicit PingPlaybackSessionLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PingPlaybackSessionParams& parameters) const override;
+	QUrlQuery query(const PingPlaybackSessionParams& parameters) const override;
+	QByteArray body(const PingPlaybackSessionParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports playback progress within a session.
+ */
+
+class ReportPlaybackProgressLoader : public Jellyfin::Support::HttpLoader<void, ReportPlaybackProgressParams> {
+public:
+	explicit ReportPlaybackProgressLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ReportPlaybackProgressParams& parameters) const override;
+	QUrlQuery query(const ReportPlaybackProgressParams& parameters) const override;
+	QByteArray body(const ReportPlaybackProgressParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports playback has stopped within a session.
+ */
+
+class ReportPlaybackStoppedLoader : public Jellyfin::Support::HttpLoader<void, ReportPlaybackStoppedParams> {
+public:
+	explicit ReportPlaybackStoppedLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ReportPlaybackStoppedParams& parameters) const override;
+	QUrlQuery query(const ReportPlaybackStoppedParams& parameters) const override;
+	QByteArray body(const ReportPlaybackStoppedParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Marks an item as played for user.
  */
@@ -76,6 +132,48 @@ protected:
 	QByteArray body(const MarkUnplayedItemParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Reports that a user has begun playing an item.
+ */
+
+class OnPlaybackStartLoader : public Jellyfin::Support::HttpLoader<void, OnPlaybackStartParams> {
+public:
+	explicit OnPlaybackStartLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const OnPlaybackStartParams& parameters) const override;
+	QUrlQuery query(const OnPlaybackStartParams& parameters) const override;
+	QByteArray body(const OnPlaybackStartParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports that a user has stopped playing an item.
+ */
+
+class OnPlaybackStoppedLoader : public Jellyfin::Support::HttpLoader<void, OnPlaybackStoppedParams> {
+public:
+	explicit OnPlaybackStoppedLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const OnPlaybackStoppedParams& parameters) const override;
+	QUrlQuery query(const OnPlaybackStoppedParams& parameters) const override;
+	QByteArray body(const OnPlaybackStoppedParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports a user's playback progress.
+ */
+
+class OnPlaybackProgressLoader : public Jellyfin::Support::HttpLoader<void, OnPlaybackProgressParams> {
+public:
+	explicit OnPlaybackProgressLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const OnPlaybackProgressParams& parameters) const override;
+	QUrlQuery query(const OnPlaybackProgressParams& parameters) const override;
+	QByteArray body(const OnPlaybackProgressParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/plugins.h

@@ -62,6 +62,62 @@ protected:
 	QByteArray body(const GetPluginsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Uninstalls a plugin.
+ */
+
+class UninstallPluginLoader : public Jellyfin::Support::HttpLoader<void, UninstallPluginParams> {
+public:
+	explicit UninstallPluginLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UninstallPluginParams& parameters) const override;
+	QUrlQuery query(const UninstallPluginParams& parameters) const override;
+	QByteArray body(const UninstallPluginParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Uninstalls a plugin by version.
+ */
+
+class UninstallPluginByVersionLoader : public Jellyfin::Support::HttpLoader<void, UninstallPluginByVersionParams> {
+public:
+	explicit UninstallPluginByVersionLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UninstallPluginByVersionParams& parameters) const override;
+	QUrlQuery query(const UninstallPluginByVersionParams& parameters) const override;
+	QByteArray body(const UninstallPluginByVersionParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Disable a plugin.
+ */
+
+class DisablePluginLoader : public Jellyfin::Support::HttpLoader<void, DisablePluginParams> {
+public:
+	explicit DisablePluginLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DisablePluginParams& parameters) const override;
+	QUrlQuery query(const DisablePluginParams& parameters) const override;
+	QByteArray body(const DisablePluginParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Enables a disabled plugin.
+ */
+
+class EnablePluginLoader : public Jellyfin::Support::HttpLoader<void, EnablePluginParams> {
+public:
+	explicit EnablePluginLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const EnablePluginParams& parameters) const override;
+	QUrlQuery query(const EnablePluginParams& parameters) const override;
+	QByteArray body(const EnablePluginParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets plugin configuration.
  */
@@ -76,6 +132,48 @@ protected:
 	QByteArray body(const GetPluginConfigurationParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Updates plugin configuration.
+ */
+
+class UpdatePluginConfigurationLoader : public Jellyfin::Support::HttpLoader<void, UpdatePluginConfigurationParams> {
+public:
+	explicit UpdatePluginConfigurationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdatePluginConfigurationParams& parameters) const override;
+	QUrlQuery query(const UpdatePluginConfigurationParams& parameters) const override;
+	QByteArray body(const UpdatePluginConfigurationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Gets a plugin's manifest.
+ */
+
+class GetPluginManifestLoader : public Jellyfin::Support::HttpLoader<void, GetPluginManifestParams> {
+public:
+	explicit GetPluginManifestLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const GetPluginManifestParams& parameters) const override;
+	QUrlQuery query(const GetPluginManifestParams& parameters) const override;
+	QByteArray body(const GetPluginManifestParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates plugin security info.
+ */
+
+class UpdatePluginSecurityInfoLoader : public Jellyfin::Support::HttpLoader<void, UpdatePluginSecurityInfoParams> {
+public:
+	explicit UpdatePluginSecurityInfoLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdatePluginSecurityInfoParams& parameters) const override;
+	QUrlQuery query(const UpdatePluginSecurityInfoParams& parameters) const override;
+	QByteArray body(const UpdatePluginSecurityInfoParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/quickconnect.h

@@ -49,6 +49,20 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Temporarily activates quick connect for five minutes.
+ */
+
+class ActivateLoader : public Jellyfin::Support::HttpLoader<void, ActivateParams> {
+public:
+	explicit ActivateLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ActivateParams& parameters) const override;
+	QUrlQuery query(const ActivateParams& parameters) const override;
+	QByteArray body(const ActivateParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Authorizes a pending quick connect request.
  */
@@ -63,6 +77,20 @@ protected:
 	QByteArray body(const AuthorizeParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Enables or disables quick connect.
+ */
+
+class AvailableLoader : public Jellyfin::Support::HttpLoader<void, AvailableParams> {
+public:
+	explicit AvailableLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const AvailableParams& parameters) const override;
+	QUrlQuery query(const AvailableParams& parameters) const override;
+	QByteArray body(const AvailableParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Attempts to retrieve authentication information.
  */

core/include/JellyfinQt/loader/http/remoteimage.h

@@ -62,6 +62,20 @@ protected:
 	QByteArray body(const GetRemoteImagesParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Downloads a remote image for an item.
+ */
+
+class DownloadRemoteImageLoader : public Jellyfin::Support::HttpLoader<void, DownloadRemoteImageParams> {
+public:
+	explicit DownloadRemoteImageLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DownloadRemoteImageParams& parameters) const override;
+	QUrlQuery query(const DownloadRemoteImageParams& parameters) const override;
+	QByteArray body(const DownloadRemoteImageParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets available remote image providers for an item.
  */

core/include/JellyfinQt/loader/http/scheduledtasks.h

@@ -76,6 +76,48 @@ protected:
 	QByteArray body(const GetTaskParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Update specified task triggers.
+ */
+
+class UpdateTaskLoader : public Jellyfin::Support::HttpLoader<void, UpdateTaskParams> {
+public:
+	explicit UpdateTaskLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateTaskParams& parameters) const override;
+	QUrlQuery query(const UpdateTaskParams& parameters) const override;
+	QByteArray body(const UpdateTaskParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Start specified task.
+ */
+
+class StartTaskLoader : public Jellyfin::Support::HttpLoader<void, StartTaskParams> {
+public:
+	explicit StartTaskLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const StartTaskParams& parameters) const override;
+	QUrlQuery query(const StartTaskParams& parameters) const override;
+	QByteArray body(const StartTaskParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Stop specified task.
+ */
+
+class StopTaskLoader : public Jellyfin::Support::HttpLoader<void, StopTaskParams> {
+public:
+	explicit StopTaskLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const StopTaskParams& parameters) const override;
+	QUrlQuery query(const StopTaskParams& parameters) const override;
+	QByteArray body(const StopTaskParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/session.h

@@ -91,6 +91,188 @@ protected:
 	QByteArray body(const GetSessionsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Issues a full general command to a client.
+ */
+
+class SendFullGeneralCommandLoader : public Jellyfin::Support::HttpLoader<void, SendFullGeneralCommandParams> {
+public:
+	explicit SendFullGeneralCommandLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SendFullGeneralCommandParams& parameters) const override;
+	QUrlQuery query(const SendFullGeneralCommandParams& parameters) const override;
+	QByteArray body(const SendFullGeneralCommandParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Issues a general command to a client.
+ */
+
+class SendGeneralCommandLoader : public Jellyfin::Support::HttpLoader<void, SendGeneralCommandParams> {
+public:
+	explicit SendGeneralCommandLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SendGeneralCommandParams& parameters) const override;
+	QUrlQuery query(const SendGeneralCommandParams& parameters) const override;
+	QByteArray body(const SendGeneralCommandParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Issues a command to a client to display a message to the user.
+ */
+
+class SendMessageCommandLoader : public Jellyfin::Support::HttpLoader<void, SendMessageCommandParams> {
+public:
+	explicit SendMessageCommandLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SendMessageCommandParams& parameters) const override;
+	QUrlQuery query(const SendMessageCommandParams& parameters) const override;
+	QByteArray body(const SendMessageCommandParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Instructs a session to play an item.
+ */
+
+class PlayLoader : public Jellyfin::Support::HttpLoader<void, PlayParams> {
+public:
+	explicit PlayLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PlayParams& parameters) const override;
+	QUrlQuery query(const PlayParams& parameters) const override;
+	QByteArray body(const PlayParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Issues a playstate command to a client.
+ */
+
+class SendPlaystateCommandLoader : public Jellyfin::Support::HttpLoader<void, SendPlaystateCommandParams> {
+public:
+	explicit SendPlaystateCommandLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SendPlaystateCommandParams& parameters) const override;
+	QUrlQuery query(const SendPlaystateCommandParams& parameters) const override;
+	QByteArray body(const SendPlaystateCommandParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Issues a system command to a client.
+ */
+
+class SendSystemCommandLoader : public Jellyfin::Support::HttpLoader<void, SendSystemCommandParams> {
+public:
+	explicit SendSystemCommandLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SendSystemCommandParams& parameters) const override;
+	QUrlQuery query(const SendSystemCommandParams& parameters) const override;
+	QByteArray body(const SendSystemCommandParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Adds an additional user to a session.
+ */
+
+class AddUserToSessionLoader : public Jellyfin::Support::HttpLoader<void, AddUserToSessionParams> {
+public:
+	explicit AddUserToSessionLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const AddUserToSessionParams& parameters) const override;
+	QUrlQuery query(const AddUserToSessionParams& parameters) const override;
+	QByteArray body(const AddUserToSessionParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Removes an additional user from a session.
+ */
+
+class RemoveUserFromSessionLoader : public Jellyfin::Support::HttpLoader<void, RemoveUserFromSessionParams> {
+public:
+	explicit RemoveUserFromSessionLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RemoveUserFromSessionParams& parameters) const override;
+	QUrlQuery query(const RemoveUserFromSessionParams& parameters) const override;
+	QByteArray body(const RemoveUserFromSessionParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Instructs a session to browse to an item or view.
+ */
+
+class DisplayContentLoader : public Jellyfin::Support::HttpLoader<void, DisplayContentParams> {
+public:
+	explicit DisplayContentLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DisplayContentParams& parameters) const override;
+	QUrlQuery query(const DisplayContentParams& parameters) const override;
+	QByteArray body(const DisplayContentParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates capabilities for a device.
+ */
+
+class PostCapabilitiesLoader : public Jellyfin::Support::HttpLoader<void, PostCapabilitiesParams> {
+public:
+	explicit PostCapabilitiesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostCapabilitiesParams& parameters) const override;
+	QUrlQuery query(const PostCapabilitiesParams& parameters) const override;
+	QByteArray body(const PostCapabilitiesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates capabilities for a device.
+ */
+
+class PostFullCapabilitiesLoader : public Jellyfin::Support::HttpLoader<void, PostFullCapabilitiesParams> {
+public:
+	explicit PostFullCapabilitiesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const PostFullCapabilitiesParams& parameters) const override;
+	QUrlQuery query(const PostFullCapabilitiesParams& parameters) const override;
+	QByteArray body(const PostFullCapabilitiesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports that a session has ended.
+ */
+
+class ReportSessionEndedLoader : public Jellyfin::Support::HttpLoader<void, ReportSessionEndedParams> {
+public:
+	explicit ReportSessionEndedLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ReportSessionEndedParams& parameters) const override;
+	QUrlQuery query(const ReportSessionEndedParams& parameters) const override;
+	QByteArray body(const ReportSessionEndedParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Reports that a session is viewing an item.
+ */
+
+class ReportViewingLoader : public Jellyfin::Support::HttpLoader<void, ReportViewingParams> {
+public:
+	explicit ReportViewingLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ReportViewingParams& parameters) const override;
+	QUrlQuery query(const ReportViewingParams& parameters) const override;
+	QByteArray body(const ReportViewingParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/startup.h

@@ -49,6 +49,20 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Completes the startup wizard.
+ */
+
+class CompleteWizardLoader : public Jellyfin::Support::HttpLoader<void, CompleteWizardParams> {
+public:
+	explicit CompleteWizardLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const CompleteWizardParams& parameters) const override;
+	QUrlQuery query(const CompleteWizardParams& parameters) const override;
+	QByteArray body(const CompleteWizardParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the initial startup wizard configuration.
  */
@@ -63,6 +77,20 @@ protected:
 	QByteArray body(const GetStartupConfigurationParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Sets the initial startup wizard configuration.
+ */
+
+class UpdateInitialConfigurationLoader : public Jellyfin::Support::HttpLoader<void, UpdateInitialConfigurationParams> {
+public:
+	explicit UpdateInitialConfigurationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateInitialConfigurationParams& parameters) const override;
+	QUrlQuery query(const UpdateInitialConfigurationParams& parameters) const override;
+	QByteArray body(const UpdateInitialConfigurationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the first user.
  */
@@ -77,6 +105,20 @@ protected:
 	QByteArray body(const GetFirstUser_2Params& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Sets remote access and UPnP.
+ */
+
+class SetRemoteAccessLoader : public Jellyfin::Support::HttpLoader<void, SetRemoteAccessParams> {
+public:
+	explicit SetRemoteAccessLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SetRemoteAccessParams& parameters) const override;
+	QUrlQuery query(const SetRemoteAccessParams& parameters) const override;
+	QByteArray body(const SetRemoteAccessParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets the first user.
  */
@@ -91,6 +133,20 @@ protected:
 	QByteArray body(const GetFirstUserParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Sets the user name and password.
+ */
+
+class UpdateStartupUserLoader : public Jellyfin::Support::HttpLoader<void, UpdateStartupUserParams> {
+public:
+	explicit UpdateStartupUserLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateStartupUserParams& parameters) const override;
+	QUrlQuery query(const UpdateStartupUserParams& parameters) const override;
+	QByteArray body(const UpdateStartupUserParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/subtitle.h

@@ -76,6 +76,48 @@ protected:
 	QByteArray body(const SearchRemoteSubtitlesParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Downloads a remote subtitle.
+ */
+
+class DownloadRemoteSubtitlesLoader : public Jellyfin::Support::HttpLoader<void, DownloadRemoteSubtitlesParams> {
+public:
+	explicit DownloadRemoteSubtitlesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DownloadRemoteSubtitlesParams& parameters) const override;
+	QUrlQuery query(const DownloadRemoteSubtitlesParams& parameters) const override;
+	QByteArray body(const DownloadRemoteSubtitlesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Upload an external subtitle file.
+ */
+
+class UploadSubtitleLoader : public Jellyfin::Support::HttpLoader<void, UploadSubtitleParams> {
+public:
+	explicit UploadSubtitleLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UploadSubtitleParams& parameters) const override;
+	QUrlQuery query(const UploadSubtitleParams& parameters) const override;
+	QByteArray body(const UploadSubtitleParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Deletes an external subtitle file.
+ */
+
+class DeleteSubtitleLoader : public Jellyfin::Support::HttpLoader<void, DeleteSubtitleParams> {
+public:
+	explicit DeleteSubtitleLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteSubtitleParams& parameters) const override;
+	QUrlQuery query(const DeleteSubtitleParams& parameters) const override;
+	QByteArray body(const DeleteSubtitleParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/syncplay.h

@@ -47,6 +47,48 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+/**
+ * @brief Notify SyncPlay group that member is buffering.
+ */
+
+class SyncPlayBufferingLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayBufferingParams> {
+public:
+	explicit SyncPlayBufferingLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayBufferingParams& parameters) const override;
+	QUrlQuery query(const SyncPlayBufferingParams& parameters) const override;
+	QByteArray body(const SyncPlayBufferingParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Join an existing SyncPlay group.
+ */
+
+class SyncPlayJoinGroupLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayJoinGroupParams> {
+public:
+	explicit SyncPlayJoinGroupLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayJoinGroupParams& parameters) const override;
+	QUrlQuery query(const SyncPlayJoinGroupParams& parameters) const override;
+	QByteArray body(const SyncPlayJoinGroupParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Leave the joined SyncPlay group.
+ */
+
+class SyncPlayLeaveGroupLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayLeaveGroupParams> {
+public:
+	explicit SyncPlayLeaveGroupLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayLeaveGroupParams& parameters) const override;
+	QUrlQuery query(const SyncPlayLeaveGroupParams& parameters) const override;
+	QByteArray body(const SyncPlayLeaveGroupParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets all SyncPlay groups.
  */
@@ -61,6 +103,244 @@ protected:
 	QByteArray body(const SyncPlayGetGroupsParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Request to move an item in the playlist in SyncPlay group.
+ */
+
+class SyncPlayMovePlaylistItemLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayMovePlaylistItemParams> {
+public:
+	explicit SyncPlayMovePlaylistItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayMovePlaylistItemParams& parameters) const override;
+	QUrlQuery query(const SyncPlayMovePlaylistItemParams& parameters) const override;
+	QByteArray body(const SyncPlayMovePlaylistItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Create a new SyncPlay group.
+ */
+
+class SyncPlayCreateGroupLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayCreateGroupParams> {
+public:
+	explicit SyncPlayCreateGroupLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayCreateGroupParams& parameters) const override;
+	QUrlQuery query(const SyncPlayCreateGroupParams& parameters) const override;
+	QByteArray body(const SyncPlayCreateGroupParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request next item in SyncPlay group.
+ */
+
+class SyncPlayNextItemLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayNextItemParams> {
+public:
+	explicit SyncPlayNextItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayNextItemParams& parameters) const override;
+	QUrlQuery query(const SyncPlayNextItemParams& parameters) const override;
+	QByteArray body(const SyncPlayNextItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request pause in SyncPlay group.
+ */
+
+class SyncPlayPauseLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayPauseParams> {
+public:
+	explicit SyncPlayPauseLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayPauseParams& parameters) const override;
+	QUrlQuery query(const SyncPlayPauseParams& parameters) const override;
+	QByteArray body(const SyncPlayPauseParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Update session ping.
+ */
+
+class SyncPlayPingLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayPingParams> {
+public:
+	explicit SyncPlayPingLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayPingParams& parameters) const override;
+	QUrlQuery query(const SyncPlayPingParams& parameters) const override;
+	QByteArray body(const SyncPlayPingParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request previous item in SyncPlay group.
+ */
+
+class SyncPlayPreviousItemLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayPreviousItemParams> {
+public:
+	explicit SyncPlayPreviousItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayPreviousItemParams& parameters) const override;
+	QUrlQuery query(const SyncPlayPreviousItemParams& parameters) const override;
+	QByteArray body(const SyncPlayPreviousItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request to queue items to the playlist of a SyncPlay group.
+ */
+
+class SyncPlayQueueLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayQueueParams> {
+public:
+	explicit SyncPlayQueueLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayQueueParams& parameters) const override;
+	QUrlQuery query(const SyncPlayQueueParams& parameters) const override;
+	QByteArray body(const SyncPlayQueueParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Notify SyncPlay group that member is ready for playback.
+ */
+
+class SyncPlayReadyLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayReadyParams> {
+public:
+	explicit SyncPlayReadyLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayReadyParams& parameters) const override;
+	QUrlQuery query(const SyncPlayReadyParams& parameters) const override;
+	QByteArray body(const SyncPlayReadyParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request to remove items from the playlist in SyncPlay group.
+ */
+
+class SyncPlayRemoveFromPlaylistLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayRemoveFromPlaylistParams> {
+public:
+	explicit SyncPlayRemoveFromPlaylistLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayRemoveFromPlaylistParams& parameters) const override;
+	QUrlQuery query(const SyncPlayRemoveFromPlaylistParams& parameters) const override;
+	QByteArray body(const SyncPlayRemoveFromPlaylistParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request seek in SyncPlay group.
+ */
+
+class SyncPlaySeekLoader : public Jellyfin::Support::HttpLoader<void, SyncPlaySeekParams> {
+public:
+	explicit SyncPlaySeekLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlaySeekParams& parameters) const override;
+	QUrlQuery query(const SyncPlaySeekParams& parameters) const override;
+	QByteArray body(const SyncPlaySeekParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request SyncPlay group to ignore member during group-wait.
+ */
+
+class SyncPlaySetIgnoreWaitLoader : public Jellyfin::Support::HttpLoader<void, SyncPlaySetIgnoreWaitParams> {
+public:
+	explicit SyncPlaySetIgnoreWaitLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlaySetIgnoreWaitParams& parameters) const override;
+	QUrlQuery query(const SyncPlaySetIgnoreWaitParams& parameters) const override;
+	QByteArray body(const SyncPlaySetIgnoreWaitParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request to set new playlist in SyncPlay group.
+ */
+
+class SyncPlaySetNewQueueLoader : public Jellyfin::Support::HttpLoader<void, SyncPlaySetNewQueueParams> {
+public:
+	explicit SyncPlaySetNewQueueLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlaySetNewQueueParams& parameters) const override;
+	QUrlQuery query(const SyncPlaySetNewQueueParams& parameters) const override;
+	QByteArray body(const SyncPlaySetNewQueueParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request to change playlist item in SyncPlay group.
+ */
+
+class SyncPlaySetPlaylistItemLoader : public Jellyfin::Support::HttpLoader<void, SyncPlaySetPlaylistItemParams> {
+public:
+	explicit SyncPlaySetPlaylistItemLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlaySetPlaylistItemParams& parameters) const override;
+	QUrlQuery query(const SyncPlaySetPlaylistItemParams& parameters) const override;
+	QByteArray body(const SyncPlaySetPlaylistItemParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request to set repeat mode in SyncPlay group.
+ */
+
+class SyncPlaySetRepeatModeLoader : public Jellyfin::Support::HttpLoader<void, SyncPlaySetRepeatModeParams> {
+public:
+	explicit SyncPlaySetRepeatModeLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlaySetRepeatModeParams& parameters) const override;
+	QUrlQuery query(const SyncPlaySetRepeatModeParams& parameters) const override;
+	QByteArray body(const SyncPlaySetRepeatModeParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request to set shuffle mode in SyncPlay group.
+ */
+
+class SyncPlaySetShuffleModeLoader : public Jellyfin::Support::HttpLoader<void, SyncPlaySetShuffleModeParams> {
+public:
+	explicit SyncPlaySetShuffleModeLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlaySetShuffleModeParams& parameters) const override;
+	QUrlQuery query(const SyncPlaySetShuffleModeParams& parameters) const override;
+	QByteArray body(const SyncPlaySetShuffleModeParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request stop in SyncPlay group.
+ */
+
+class SyncPlayStopLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayStopParams> {
+public:
+	explicit SyncPlayStopLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayStopParams& parameters) const override;
+	QUrlQuery query(const SyncPlayStopParams& parameters) const override;
+	QByteArray body(const SyncPlayStopParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Request unpause in SyncPlay group.
+ */
+
+class SyncPlayUnpauseLoader : public Jellyfin::Support::HttpLoader<void, SyncPlayUnpauseParams> {
+public:
+	explicit SyncPlayUnpauseLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const SyncPlayUnpauseParams& parameters) const override;
+	QUrlQuery query(const SyncPlayUnpauseParams& parameters) const override;
+	QByteArray body(const SyncPlayUnpauseParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/http/system.h

@@ -135,6 +135,34 @@ protected:
 	QByteArray body(const PostPingSystemParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Restarts the application.
+ */
+
+class RestartApplicationLoader : public Jellyfin::Support::HttpLoader<void, RestartApplicationParams> {
+public:
+	explicit RestartApplicationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const RestartApplicationParams& parameters) const override;
+	QUrlQuery query(const RestartApplicationParams& parameters) const override;
+	QByteArray body(const RestartApplicationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Shuts down the application.
+ */
+
+class ShutdownApplicationLoader : public Jellyfin::Support::HttpLoader<void, ShutdownApplicationParams> {
+public:
+	explicit ShutdownApplicationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const ShutdownApplicationParams& parameters) const override;
+	QUrlQuery query(const ShutdownApplicationParams& parameters) const override;
+	QByteArray body(const ShutdownApplicationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Gets wake on lan information.
  */

core/include/JellyfinQt/loader/http/user.h

@@ -84,6 +84,34 @@ protected:
 	QByteArray body(const GetUserByIdParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Deletes a user.
+ */
+
+class DeleteUserLoader : public Jellyfin::Support::HttpLoader<void, DeleteUserParams> {
+public:
+	explicit DeleteUserLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteUserParams& parameters) const override;
+	QUrlQuery query(const DeleteUserParams& parameters) const override;
+	QByteArray body(const DeleteUserParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a user.
+ */
+
+class UpdateUserLoader : public Jellyfin::Support::HttpLoader<void, UpdateUserParams> {
+public:
+	explicit UpdateUserLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateUserParams& parameters) const override;
+	QUrlQuery query(const UpdateUserParams& parameters) const override;
+	QByteArray body(const UpdateUserParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Authenticates a user.
  */
@@ -98,6 +126,62 @@ protected:
 	QByteArray body(const AuthenticateUserParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Updates a user configuration.
+ */
+
+class UpdateUserConfigurationLoader : public Jellyfin::Support::HttpLoader<void, UpdateUserConfigurationParams> {
+public:
+	explicit UpdateUserConfigurationLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateUserConfigurationParams& parameters) const override;
+	QUrlQuery query(const UpdateUserConfigurationParams& parameters) const override;
+	QByteArray body(const UpdateUserConfigurationParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a user's easy password.
+ */
+
+class UpdateUserEasyPasswordLoader : public Jellyfin::Support::HttpLoader<void, UpdateUserEasyPasswordParams> {
+public:
+	explicit UpdateUserEasyPasswordLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateUserEasyPasswordParams& parameters) const override;
+	QUrlQuery query(const UpdateUserEasyPasswordParams& parameters) const override;
+	QByteArray body(const UpdateUserEasyPasswordParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a user's password.
+ */
+
+class UpdateUserPasswordLoader : public Jellyfin::Support::HttpLoader<void, UpdateUserPasswordParams> {
+public:
+	explicit UpdateUserPasswordLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateUserPasswordParams& parameters) const override;
+	QUrlQuery query(const UpdateUserPasswordParams& parameters) const override;
+	QByteArray body(const UpdateUserPasswordParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Updates a user policy.
+ */
+
+class UpdateUserPolicyLoader : public Jellyfin::Support::HttpLoader<void, UpdateUserPolicyParams> {
+public:
+	explicit UpdateUserPolicyLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const UpdateUserPolicyParams& parameters) const override;
+	QUrlQuery query(const UpdateUserPolicyParams& parameters) const override;
+	QByteArray body(const UpdateUserPolicyParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 /**
  * @brief Authenticates a user by name.
  */

core/include/JellyfinQt/loader/http/videos.h

@@ -61,6 +61,34 @@ protected:
 	QByteArray body(const GetAdditionalPartParams& parameters) const override;
 	QNetworkAccessManager::Operation operation() const override;
 };
+/**
+ * @brief Removes alternate video sources.
+ */
+
+class DeleteAlternateSourcesLoader : public Jellyfin::Support::HttpLoader<void, DeleteAlternateSourcesParams> {
+public:
+	explicit DeleteAlternateSourcesLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const DeleteAlternateSourcesParams& parameters) const override;
+	QUrlQuery query(const DeleteAlternateSourcesParams& parameters) const override;
+	QByteArray body(const DeleteAlternateSourcesParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
+/**
+ * @brief Merges videos into a single record.
+ */
+
+class MergeVersionsLoader : public Jellyfin::Support::HttpLoader<void, MergeVersionsParams> {
+public:
+	explicit MergeVersionsLoader(ApiClient *apiClient = nullptr);
+
+protected:
+	QString path(const MergeVersionsParams& parameters) const override;
+	QUrlQuery query(const MergeVersionsParams& parameters) const override;
+	QByteArray body(const MergeVersionsParams& parameters) const override;
+	QNetworkAccessManager::Operation operation() const override;
+};
 
 } // NS HTTP
 } // NS Loader

core/include/JellyfinQt/loader/requesttypes.h

@@ -27728,6 +27728,33 @@ public:
 	void setPlayCommand(PlayCommand newPlayCommand);
 
 	
+	/**
+	 * @brief Optional. The index of the audio stream to play.	
+	 */
+	const qint32 &audioStreamIndex() const;
+	void setAudioStreamIndex(qint32 newAudioStreamIndex);
+	bool audioStreamIndexNull() const;
+	void setAudioStreamIndexNull();
+	
+	
+	/**
+	 * @brief Optional. The media source id.	
+	 */
+	const QString &mediaSourceId() const;
+	void setMediaSourceId(QString newMediaSourceId);
+	bool mediaSourceIdNull() const;
+	void setMediaSourceIdNull();
+	
+	
+	/**
+	 * @brief Optional. The start index.	
+	 */
+	const qint32 &startIndex() const;
+	void setStartIndex(qint32 newStartIndex);
+	bool startIndexNull() const;
+	void setStartIndexNull();
+	
+	
 	/**
 	 * @brief The starting position of the first item.	
 	 */
@@ -27737,6 +27764,15 @@ public:
 	void setStartPositionTicksNull();
 	
 	
+	/**
+	 * @brief Optional. The index of the subtitle stream to play.	
+	 */
+	const qint32 &subtitleStreamIndex() const;
+	void setSubtitleStreamIndex(qint32 newSubtitleStreamIndex);
+	bool subtitleStreamIndexNull() const;
+	void setSubtitleStreamIndexNull();
+	
+	
 private:
 	// Required path parameters
 	QString m_sessionId;
@@ -27746,7 +27782,11 @@ private:
 	PlayCommand m_playCommand;
 
 	// Optional query parameters
+	std::optional<qint32> m_audioStreamIndex = std::nullopt;
+	QString m_mediaSourceId;
+	std::optional<qint32> m_startIndex = std::nullopt;
 	std::optional<qint64> m_startPositionTicks = std::nullopt;
+	std::optional<qint32> m_subtitleStreamIndex = std::nullopt;
 
 
 };

core/include/JellyfinQt/model/controllablesession.h

@@ -0,0 +1,172 @@
+#ifndef JELLYFIN_MODEL_CONTROLLABLESESSION_H
+#define JELLYFIN_MODEL_CONTROLLABLESESSION_H
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QSharedPointer>
+
+#include "JellyfinQt/dto/sessioninfo.h"
+
+namespace Jellyfin {
+
+class ApiClient;
+
+namespace DTO {
+class ClientCapabilities;
+} // NS DTO
+
+namespace Model {
+
+class PlaybackManager;
+
+class DeviceTypeClass { Q_GADGET
+public:
+    enum Value {
+        Unknown,
+        Tv,
+        Computer,
+        Phone
+    };
+    Q_ENUM(Value)
+};
+
+class MediaTypeClass {
+    Q_GADGET
+public:
+    enum Value {
+        None  = 0x0,
+        Audio = 0x1,
+        Video = 0x2,
+        Photo = 0x4
+    };
+    Q_DECLARE_FLAGS(MediaTypes, Value)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(MediaTypeClass::MediaTypes)
+
+using DeviceType = DeviceTypeClass::Value;
+using MediaTypes = MediaTypeClass::MediaTypes;
+
+/**
+ * @brief Abstract class for describing a playback session that can be controlled.
+ *
+ * Main purpose for this class is to hold information for displaying it in a UI for an user to select
+ * and to create an implementation of a PlaybackManager instance to control this session.
+ */
+class ControllableSession : public QObject {
+    Q_OBJECT
+public:
+    explicit ControllableSession(QObject *parent = nullptr);
+    /**
+     * @brief An unique id for this session.
+     */
+    virtual QString id() const = 0;
+    /**
+     * @brief An human-readable name for this session
+     */
+    virtual QString name() const = 0;
+    /**
+     * @brief The app for this session
+     */
+    virtual QString appName() const = 0;
+    virtual DeviceType deviceType() const = 0;
+
+    /**
+     * @brief user The username of who started this session
+     */
+    virtual QString userName() const = 0;
+    /**
+     * @brief Creates a playbackManager for this device. This PlaybackManager has no
+     * QObject parent and must be cleaned up by the caller.
+     */
+    virtual PlaybackManager *createPlaybackManager() const = 0;
+};
+
+/**
+ * @brief Dummy session representing this device.
+ */
+class LocalSession : public ControllableSession {
+    Q_OBJECT
+public:
+    LocalSession(ApiClient &apiClient, QObject *parent = nullptr);
+    QString id() const override;
+    QString name() const override;
+    QString appName() const override;
+    DeviceType deviceType() const override;
+    QString userName() const override;
+    PlaybackManager *createPlaybackManager() const override;
+private:
+    ApiClient &m_apiClient;
+};
+
+/**
+ * @brief A session on the Jellyfin server that can be controlled.
+ */
+class ControllableJellyfinSession : public ControllableSession {
+    Q_OBJECT
+public:
+    ControllableJellyfinSession(QSharedPointer<DTO::SessionInfo> info, ApiClient &apiClient, QObject *parent = nullptr);
+    QString id() const override;
+    QString name() const override;
+    QString appName() const override;
+    DeviceType deviceType() const override;
+    QString userName() const override;
+    PlaybackManager *createPlaybackManager() const override;
+private:
+    QSharedPointer<DTO::SessionInfo> m_data;
+    ApiClient &m_apiClient;
+};
+
+/**
+ * Abstract class for finding remotely controllable sessions
+ */
+class RemoteSessionScanner : public QObject {
+    Q_OBJECT
+public:
+    explicit RemoteSessionScanner(QObject *parent = nullptr);
+    /**
+     * The session scanner should start discovering sessions
+     */
+    virtual void startScanning() = 0;
+    /**
+     * The session scanner should stop discovering sessions
+     */
+    virtual void stopScanning() = 0;
+signals:
+    /**
+     * This signal should be emitted when an session has been discovered.
+     * The session should be reparented to whoever is listening for this signal.
+     */
+    void sessionFound(Jellyfin::Model::ControllableSession *session);
+    /**
+     * Should be emitted when an session is gone.
+     */
+    void sessionLost(const QString &sessionId);
+    /**
+     * Should be emitted when the listener should delete all sessions by this discoverer.
+     */
+    void resetSessions();
+};
+
+
+class RemoteJellyfinSessionScannerPrivate;
+/**
+ * @brief Lists controllable Jellyfin sessions from the Jellyfin server
+ */
+class RemoteJellyfinSessionScanner : public RemoteSessionScanner {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(RemoteJellyfinSessionScanner);
+public:
+    explicit RemoteJellyfinSessionScanner(ApiClient *client, QObject *parent);
+    virtual ~RemoteJellyfinSessionScanner();
+
+    void startScanning() override;
+    void stopScanning() override;
+private:
+    QScopedPointer<RemoteJellyfinSessionScannerPrivate> d_ptr;
+};
+
+} // NS Model
+} // NS Jellyfin
+
+#endif // JELLYFIN_MODEL_CONTROLLABLESESSION_H

core/include/JellyfinQt/model/playbackmanager.h

@@ -0,0 +1,242 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2021-2022 Chris Josten and the Sailfin Contributors.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef JELLYFIN_MODEL_PLAYBACKMANAGER_H
+#define JELLYFIN_MODEL_PLAYBACKMANAGER_H
+
+#include <QLoggingCategory>
+#include <QObject>
+#include <QSharedPointer>
+
+#include <JellyfinQt/dto/playmethod.h>
+#include <JellyfinQt/model/player.h>
+
+namespace Jellyfin {
+namespace Model {
+
+class Item;
+class Playlist;
+
+Q_DECLARE_LOGGING_CATEGORY(playbackManager);
+
+class PlaybackManagerErrorClass {
+    Q_GADGET
+public:
+    enum Value {
+        NoError,
+        PlaybackInfoError,
+        RemoteClientNotReachable,
+        PlayerGeneralError
+    };
+    Q_ENUM(Value);
+};
+
+using PlaybackManagerError = PlaybackManagerErrorClass::Value;
+
+class PlaybackManagerPrivate;
+/**
+ * @brief Base class for a playback manager.
+ *
+ * Besides some glue code for the properties,
+ * most of the actual playback logic is implemented in the two subclasses: {@link LocalPlaybackManager}
+ * and {@link RemotePlaybackManager}
+ */
+class PlaybackManager : public QObject {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(PlaybackManager);
+    Q_PROPERTY(bool resumePlayback READ resumePlayback WRITE setResumePlayback NOTIFY resumePlaybackChanged)
+    Q_PROPERTY(int audioIndex READ audioIndex WRITE setAudioIndex NOTIFY audioIndexChanged)
+    Q_PROPERTY(int subtitleIndex READ subtitleIndex WRITE setSubtitleIndex NOTIFY subtitleIndexChanged)
+    /**
+     * @brief The position in ticks in the currently playing item
+     */
+    Q_PROPERTY(qint64 position READ position NOTIFY positionChanged)
+    /**
+     * @brief The duration in ticks of the currently playing item
+     */
+    Q_PROPERTY(qint64 duration READ duration NOTIFY durationChanged)
+    /**
+     * @brief Whether the playbackmanager is currently able to seek
+     */
+    Q_PROPERTY(bool seekable READ seekable NOTIFY seekableChanged)
+    /**
+     * @brief Whether the currently playing item has audio
+     */
+    Q_PROPERTY(bool hasAudio READ hasAudio NOTIFY hasAudioChanged)
+    /**
+     * @brief Whether the currently playing item has video
+     */
+    Q_PROPERTY(bool hasVideo READ hasVideo NOTIFY hasVideoChanged)
+    Q_PROPERTY(Jellyfin::Model::PlayerStateClass::Value playbackState READ playbackState NOTIFY playbackStateChanged)
+    Q_PROPERTY(Jellyfin::Model::MediaStatusClass::Value mediaStatus READ mediaStatus NOTIFY mediaStatusChanged)
+    Q_PROPERTY(int queueIndex READ queueIndex NOTIFY queueIndexChanged)
+public:
+    explicit PlaybackManager(QObject *parent = nullptr);
+    virtual ~PlaybackManager();
+    void swap(PlaybackManager& other);
+
+    ApiClient * apiClient() const;
+    void setApiClient(ApiClient *apiClient);
+
+    // Getters
+    QSharedPointer<Item> currentItem() const;
+    Playlist *queue() const;
+    int queueIndex() const;
+
+    bool resumePlayback() const;
+    void setResumePlayback(bool newResumePlayback);
+    int audioIndex() const;
+    void setAudioIndex(int newAudioIndex);
+    int subtitleIndex() const;
+    void setSubtitleIndex(int newSubtitleIndex);
+
+    virtual PlayerState playbackState() const = 0;
+    virtual MediaStatus mediaStatus() const = 0;
+    virtual bool hasNext() const = 0;
+    virtual bool hasPrevious() const = 0;
+    virtual PlaybackManagerError error() const = 0;
+
+    virtual const QString &errorString() const = 0;
+    virtual qint64 position() const = 0;
+    virtual qint64 duration() const = 0;
+    virtual bool seekable() const = 0;
+    virtual bool hasAudio() const = 0;
+    virtual bool hasVideo() const = 0;
+
+    /**
+     * @brief Start playing the given item
+     */
+    virtual void playItem(QSharedPointer<Model::Item> item) = 0;
+    /**
+     * @brief Set the playlist to the given playlist and start playing the item at the given index
+     * @param items The list of items to play
+     * @param index Index of the item to play
+     */
+    virtual void playItemInList(const QList<QSharedPointer<Model::Item>> &items, int index) = 0;
+    static const qint64 MS_TICK_FACTOR = 10000;
+protected:
+    void setItem(QSharedPointer<Item> item);
+    void setQueueIndex(int index);
+
+signals:
+    void playbackStateChanged(Jellyfin::Model::PlayerStateClass::Value newPlaybackState);
+    void mediaStatusChanged(Jellyfin::Model::MediaStatusClass::Value newMediaStatus);
+    void queueChanged(Jellyfin::Model::Playlist *newPlaylist);
+    void hasNextChanged(bool newHasNext);
+    void hasPreviousChanged(bool newHasPrevious);
+    void itemChanged();
+    void queueIndexChanged(int index);
+    void errorChanged(Jellyfin::Model::PlaybackManagerErrorClass::Value newError);
+    void errorStringChanged(const QString &newErrorString);
+    void positionChanged(qint64 newPosition);
+    void durationChanged(qint64 newDuration);
+    void seekableChanged(bool newSeekable);
+    void hasAudioChanged();
+    void hasVideoChanged();
+    void resumePlaybackChanged(bool newPlaybackChanged);
+    void audioIndexChanged(int newAudioIndex);
+    void subtitleIndexChanged(int newSubtitleIndex);
+
+public slots:
+    virtual void pause() = 0;
+    virtual void play() = 0;
+    virtual void playItemId(const QString &id) = 0;
+    virtual void previous() = 0;
+    virtual void next() = 0;
+    /**
+     * @brief Play the item at the index in the current playlist
+     * @param index the item to go to;
+     */
+    virtual void goTo(int index) = 0;
+    virtual void stop() = 0;
+    virtual void seek(qint64 pos) = 0;
+protected:
+    explicit PlaybackManager(PlaybackManagerPrivate *d, QObject *parent = nullptr);
+    QScopedPointer<PlaybackManagerPrivate> d_ptr;
+};
+
+class LocalPlaybackManagerPrivate;
+/**
+ * @brief Controls playback whithin this app.
+ *
+ * This class mostly consists of bookkeeping between the actual media player implementation (which is
+ * abstracted into yet another class) and the ViewModel.
+ *
+ * It does things like:
+ * * Fetching the actual media URL of an item and deciding which playback method to use
+ * * Managing the current playlist state and instructing the media player which item to play next
+ * * Keeping track of the playback state that the user would expect from a media player,
+ *   instead of what the media player implementation reports.
+ *
+ */
+class LocalPlaybackManager : public PlaybackManager {
+    Q_DECLARE_PRIVATE(LocalPlaybackManager);
+    Q_OBJECT
+    Q_PROPERTY(Jellyfin::Model::Player *player READ player NOTIFY playerChanged)
+    Q_PROPERTY(Jellyfin::DTO::PlayMethodClass::Value playMethod READ playMethod NOTIFY playMethodChanged)
+    Q_PROPERTY(QUrl streamUrl READ streamUrl NOTIFY streamUrlChanged)
+public:
+    explicit LocalPlaybackManager(QObject *parent = nullptr);
+
+    Player *player() const;
+    QString sessionId() const;
+    DTO::PlayMethod playMethod() const;
+    const QUrl &streamUrl() const;
+
+    PlayerState playbackState() const override;
+    MediaStatus mediaStatus() const override;
+    PlaybackManagerError error() const override;
+    const QString& errorString() const override;
+    qint64 position() const override;
+    qint64 duration() const override;
+    bool seekable() const override;
+    bool hasAudio() const override;
+    bool hasVideo() const override;
+
+    bool hasNext() const override;
+    bool hasPrevious() const override;
+
+    void playItemInList(const QList<QSharedPointer<Model::Item>> &items, int index) override;
+
+public slots:
+    void pause() override;
+    void play() override;
+    void playItem(QSharedPointer<Model::Item> item) override;
+    void playItemId(const QString &itemId) override;
+    void next() override;
+    void previous() override;
+    void stop() override;
+    void seek(qint64 pos) override;
+    void goTo(int index) override;
+signals:
+    void playerChanged(Jellyfin::Model::Player *newPlayer);
+    void playMethodChanged(Jellyfin::DTO::PlayMethodClass::Value newPlayMethod);
+    void streamUrlChanged(const QUrl &newStreamUrl);
+};
+
+/**
+ * @brief Controls playback for remote devices, such as other Jellyfin clients, over the network.
+ */
+class RemoteJellyfinPlaybackManager {
+
+};
+
+} // NS Model
+} // NS Jellyfin
+
+#endif // JELLYFIN_MODEL_PLAYBACKMANAGER_H

core/include/JellyfinQt/model/playbackreporter.h

@@ -0,0 +1,58 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2021-2022 Chris Josten and the Sailfin Contributors.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef JELLYFIN_MODEL_PLAYBACKREPORTER_H
+#define JELLYFIN_MODEL_PLAYBACKREPORTER_H
+
+#include <QLoggingCategory>
+#include <QObject>
+#include <QScopedPointer>
+
+namespace Jellyfin {
+
+class ApiClient;
+
+namespace Model {
+
+Q_DECLARE_LOGGING_CATEGORY(playbackReporter);
+
+class LocalPlaybackManager;
+
+class PlaybackReporterPrivate;
+/**
+ * @brief Reports the current playback state to the Jellyfin server
+ *
+ * Set a playbackManager using setPlaybackmanager() and this class
+ * will do its job.
+ */
+class PlaybackReporter : public QObject {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(PlaybackReporter);
+public:
+    explicit PlaybackReporter(QObject *parent = nullptr);
+
+    void setPlaybackManager(LocalPlaybackManager *playbackManager);
+private:
+    PlaybackReporterPrivate *d_ptr;
+};
+
+}
+}
+
+#endif //JELLYFIN_MODEL_PLAYBACKREPORTER_H
+

core/include/JellyfinQt/model/player.h

@@ -0,0 +1,152 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2021-2022 Chris Josten and the Sailfin Contributors.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef JELLYFIN_MODEL_PLAYER_H
+#define JELLYFIN_MODEL_PLAYER_H
+
+#include <QLoggingCategory>
+#include <QObject>
+#include <QUrl>
+
+namespace Jellyfin {
+namespace Model {
+
+Q_DECLARE_LOGGING_CATEGORY(player)
+
+class PlayerStateClass {
+    Q_GADGET
+public:
+    enum Value {
+        Stopped,
+        Playing,
+        Paused
+    };
+    Q_ENUM(Value);
+private:
+    PlayerStateClass() {}
+};
+
+class MediaStatusClass {
+    Q_GADGET
+public:
+    enum Value {
+        NoMedia,
+        Loading,
+        Loaded,
+        Stalled,
+        Buffering,
+        Buffered,
+        EndOfMedia,
+        Error
+    };
+    Q_ENUM(Value);
+private:
+    MediaStatusClass() {}
+};
+
+using PlayerState = PlayerStateClass::Value;
+using MediaStatus = MediaStatusClass::Value;
+
+/**
+ * @brief Abstract class for a player
+ */
+class Player : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(Jellyfin::Model::PlayerStateClass::Value state READ state NOTIFY stateChanged)
+    Q_PROPERTY(Jellyfin::Model::MediaStatusClass::Value mediaStatus READ mediaStatus NOTIFY mediaStatusChanged)
+    Q_PROPERTY(qint64 position READ position NOTIFY positionChanged)
+    Q_PROPERTY(qint64 duration READ duration NOTIFY durationChanged)
+    Q_PROPERTY(bool seekable READ seekable NOTIFY seekableChanged)
+    Q_PROPERTY(bool hasAudio READ hasAudio NOTIFY hasAudioChanged)
+    Q_PROPERTY(bool hasVideo READ hasVideo NOTIFY hasVideoChanged)
+    Q_PROPERTY(QString errorString READ errorString NOTIFY errorStringChanged)
+    // Used in QML by the VideoOutput
+    Q_PROPERTY(QObject* videoOutputSource READ videoOutputSource NOTIFY videoOutputSourceChanged);
+public:
+public:
+    ~Player();
+    virtual PlayerState state() const = 0;
+    virtual MediaStatus mediaStatus() const = 0;
+    virtual qint64 position() const = 0;
+    virtual qint64 duration() const = 0;
+    virtual bool seekable() const = 0;
+    virtual bool hasVideo() const = 0;
+    virtual bool hasAudio() const = 0;
+    virtual QString errorString() const = 0;
+    virtual QObject *videoOutputSource() const = 0;
+public slots:
+    virtual void pause() = 0;
+    virtual void play(qint64 startPos = 0) = 0;
+    virtual void stop() = 0;
+    virtual void seek(qint64 position) = 0;
+    virtual void setMedia(const QUrl &url, int audioIndex = -1, int subTitleIndex = -1) = 0;
+
+signals:
+    void stateChanged(Jellyfin::Model::PlayerStateClass::Value newState);
+    void mediaStatusChanged(Jellyfin::Model::MediaStatusClass::Value newMediaStatus);
+    void positionChanged(qint64 newPosition);
+    void durationChanged(qint64 newDuration);
+    void errorStringChanged();
+    /**
+     * @brief Sent when the position changed due to calling the seek method.
+     */
+    void seeked();
+    void seekableChanged(bool seekable);
+    void hasAudioChanged();
+    void hasVideoChanged();
+    void aboutToFinish();
+    void videoOutputSourceChanged();
+};
+
+#define USE_QTMULTIMEDIA_PLAYER
+#ifdef USE_QTMULTIMEDIA_PLAYER
+class QtMultimediaPlayerPrivate;
+/**
+ * @brief Player implementation that uses QtMultimedia
+ */
+class QtMultimediaPlayer : public Player {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QtMultimediaPlayer);
+public:
+    explicit QtMultimediaPlayer(QObject *parent = nullptr);
+    virtual ~QtMultimediaPlayer();
+    PlayerState state() const override;
+    MediaStatus mediaStatus() const override;
+    qint64 position() const override;
+    qint64 duration() const override;
+    bool seekable() const override;
+    bool hasVideo() const override;
+    bool hasAudio() const override;
+    QString errorString() const override;
+    QObject *videoOutputSource() const override;
+public slots:
+    void pause() override;
+    void play(qint64 startPos = 0) override;
+    void stop() override;
+    void seek(qint64 position) override;
+    void setMedia(const QUrl &url, int audioIndex, int subtitleIndex) override;
+private:
+    QScopedPointer<QtMultimediaPlayerPrivate> d_ptr;
+};
+#endif // ifdef USE_QTMULTIMEDIA_PLAYER
+
+} // NS Model
+} // NS Jellyfin
+
+#endif // JELLYFIN_MODEL_PLAYER_H

core/include/JellyfinQt/model/playlist.h

@@ -1,6 +1,6 @@
 /*
  * Sailfin: a Jellyfin client written using Qt
- * Copyright (C) 2021 Chris Josten and the Sailfin Contributors.
+ * Copyright (C) 2021-2022 Chris Josten and the Sailfin Contributors.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -72,6 +72,11 @@ public:
      */
     void next();
 
+    /**
+     * @brief Returns all items in the queue
+     */
+    QList<QSharedPointer<Item>> queueAndList() const;
+
     int queueSize() { return m_queue.size(); };
     int listSize() const { return m_list.size(); };
     int totalSize() const { return m_queue.size() + m_list.size(); }
@@ -96,9 +101,9 @@ public:
     void clearList();
 
     /**
-     * @brief Appends all items from the given itemModel to this list
+     * @brief Appends all items from the given item list to this list
      */
-    void appendToList(ViewModel::ItemModel &model);
+    void appendToList(const QList<QSharedPointer<Item>> &model);
 
     /**
      * @brief appendToList Appends a single item to the current list

core/include/JellyfinQt/model/remotejellyfinplayback.h

@@ -0,0 +1,101 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2023 Chris Josten and the Sailfin Contributors.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef JELLYFIN_MODEL_REMOTEJELLYFINPLAYBACK_H
+#define JELLYFIN_MODEL_REMOTEJELLYFINPLAYBACK_H
+
+#include <JellyfinQt/dto/generalcommandtype.h>
+#include <JellyfinQt/dto/playcommand.h>
+#include <JellyfinQt/dto/playstatecommand.h>
+#include <JellyfinQt/dto/sessioninfo.h>
+#include <JellyfinQt/model/playbackmanager.h>
+#include <JellyfinQt/support/loader.h>
+
+#include <QJsonObject>
+#include <QSharedPointer>
+#include <QTimer>
+
+#include <optional>
+
+namespace Jellyfin {
+
+class ApiClient;
+
+namespace Model {
+
+class RemoteJellyfinPlayback : public PlaybackManager {
+public:
+    RemoteJellyfinPlayback(ApiClient &apiClient, QString sessionId, QObject *parent = nullptr);
+    virtual ~RemoteJellyfinPlayback();
+
+    // PlaybackManager
+    PlayerState playbackState() const override;
+    MediaStatus mediaStatus() const override;
+    bool hasNext() const override;
+    bool hasPrevious() const override;
+    PlaybackManagerError error() const override;
+    const QString &errorString() const override;
+    qint64 position() const override;
+    qint64 duration() const override;
+    bool seekable() const override;
+    bool hasAudio() const override;
+    bool hasVideo() const override;
+    void playItem(QSharedPointer<Item> item) override;
+    void playItemInList(const QList<QSharedPointer<Item> > &items, int index) override;
+
+public slots:
+    void pause() override;
+    void play() override;
+    void playItemId(const QString &id) override;
+    void previous() override;
+    void next() override;
+    void goTo(int index) override;
+    void stop() override;
+    void seek(qint64 pos) override;
+private slots:
+    void onPositionTimerFired();
+    void onSessionInfoUpdated(const QString &sessionId, const DTO::SessionInfo &sessionInfo);
+private:
+    void sendPlaystateCommand(DTO::PlaystateCommand command, qint64 seekTicks = -1);
+    void sendGeneralCommand(DTO::GeneralCommandType command, QJsonObject arguments = QJsonObject());
+    void sendCommand(Support::LoaderBase *loader);
+    void playItemInList(const QStringList &items, int index, qint64 resumeTicks = -1);
+    /**
+     * @brief isQueueSame Checks if the items in the list are the same as in the queue
+     * @param items The item ids to compare to the queue
+     * @return True if the same, otherwise false
+     */
+    bool isQueueSame(QList<QueueItem> itemIds);
+    /**
+     * Updates the now playing queue, with the given items
+     * @param itemIds The item ids to load
+     */
+    void updateQueue(QList<QueueItem> itemIds);
+    ApiClient &m_apiClient;
+    QString m_sessionId;
+    std::optional<DTO::SessionInfo> m_lastSessionInfo;
+    QTimer *m_positionTimer;
+    qint64 m_position = 0;
+};
+
+
+} // NS Model
+} // NS Jellyfin
+
+
+#endif // JELLYFIN_MODEL_REMOTEJELLYFINPLAYBACK_H

core/include/JellyfinQt/platform/freedesktop/mediaplayer2player.h

@@ -16,6 +16,8 @@
 #include <QtCore/QObject>
 #include <QtDBus/QtDBus>
 #include <QMediaPlayer>
+#include "JellyfinQt/model/player.h"
+
 QT_BEGIN_NAMESPACE
 class QByteArray;
 template<class T> class QList;
@@ -190,9 +192,9 @@ private:
     ViewModel::PlatformMediaControl *m_mediaControl;
     void notifyPropertiesChanged(QStringList properties);
 private slots:
-    void onCurrentItemChanged(ViewModel::Item *newItem);
-    void onPlaybackStateChanged(QMediaPlayer::State state);
-    void onMediaStatusChanged(QMediaPlayer::MediaStatus status);
+    void onCurrentItemChanged();
+    void onPlaybackStateChanged(Jellyfin::Model::PlayerStateClass::Value state);
+    void onMediaStatusChanged(Jellyfin::Model::MediaStatusClass::Value status);
     void onPositionChanged(qint64 position);
     void onSeekableChanged(bool seekable);
     void onPlaybackManagerChanged(ViewModel::PlaybackManager *newPlaybackManager);

core/include/JellyfinQt/support/jsonconv.h

@@ -57,6 +57,7 @@ extern template QString toString(const float &source, convertType<float>);
 extern template QString toString(const double &source, convertType<double>);
 extern template QString toString(const bool &source, convertType<bool>);
 extern template QString toString(const QString &source, convertType<QString>);
+extern template QString toString(const QStringList &source, convertType<QStringList>);
 
 } // NS Support
 } // NS Jellyfin

core/include/JellyfinQt/support/jsonconvimpl.h

@@ -155,6 +155,8 @@ QString toString(const T &source, convertType<T>) {
         return QJsonDocument(val.toArray()).toJson(format);
     case QJsonValue::Object:
         return QJsonDocument(val.toObject()).toJson(format);
+    case QJsonValue::String:
+        return val.toString();
     case QJsonValue::Null:
     default:
         return QString();

core/include/JellyfinQt/support/loader.h

@@ -62,40 +62,11 @@ static const int HTTP_TIMEOUT = 30000; // 30 seconds;
  */
 class LoaderBase : public QObject {
     Q_OBJECT
-signals:
-    /**
-     * @brief Emitted when an error has occurred during loading and no result
-     * is available.
-     */
-    void error(QString message = QString());
-    /**
-     * @brief Emitted when data was successfully loaded.
-     */
-    void ready();
-};
-
-/**
- * Interface describing a way to load items. Used to abstract away
- * the difference between loading from a cache or loading over the network.
- *
- * To implement this class, implement prepareLoad() and load(). These are always called
- * in the same order, but prepareLoad() must always be called on the same thread as the
- * m_apiClient, while load() may be called on another thread.
- *
- * @note: Loaders should NEVER call load() again while load() is running on another
- * thread or change the apiClient while running. This will result in undefined behaviour.
- * Please use a Mutex to enforce this.
- *
- * @tparam R the type of data that should be fetched, R for result.
- * @tparam P the type of paramaters given, to determine which resource should
- *           be loaded.
- */
-template <typename R, typename P>
-class Loader : public LoaderBase {
-public:
-    explicit Loader(ApiClient *apiClient)
+protected:
+    explicit LoaderBase(ApiClient *apiClient)
         : m_apiClient(apiClient) {}
 
+public:
     /**
      * @brief load Loads the given resource asynchronously.
      */
@@ -103,19 +74,6 @@ public:
         throw LoadException(QStringLiteral("Loader not set"));
     }
 
-    /**
-     * @brief Retrieves the loaded resource. Only valid after the ready signal has been emitted.
-     *
-     * @return The loaded resource.
-     */
-    R result() const {
-        return m_result.value();
-    }
-
-    bool hasResult() const {
-        return m_result;
-    }
-
     /**
      * @returns whether this loader is already fetching a resource
      */
@@ -136,6 +94,61 @@ public:
     void setApiClient(ApiClient *newApiClient) { m_apiClient = newApiClient; }
     ApiClient *apiClient() const { return m_apiClient; }
 
+signals:
+    /**
+     * @brief Emitted when an error has occurred during loading and no result
+     * is available.
+     */
+    void error(QString message = QString());
+    /**
+     * @brief Emitted when data was successfully loaded.
+     */
+    void ready();
+protected:
+    Jellyfin::ApiClient *m_apiClient;
+    bool m_isRunning = false;
+
+    void stopWithError(QString message = QString()) {
+        m_isRunning = false;
+        emit this->error(message);
+    }
+};
+
+/**
+ * Interface describing a way to load items. Used to abstract away
+ * the difference between loading from a cache or loading over the network.
+ *
+ * To implement this class, implement prepareLoad() and load(). These are always called
+ * in the same order, but prepareLoad() must always be called on the same thread as the
+ * m_apiClient, while load() may be called on another thread.
+ *
+ * @note: Loaders should NEVER call load() again while load() is running on another
+ * thread or change the apiClient while running. This will result in undefined behaviour.
+ * Please use a Mutex to enforce this.
+ *
+ * @tparam R the type of data that should be fetched, R for result.
+ * @tparam P the type of paramaters given, to determine which resource should
+ *           be loaded.
+ */
+template <typename R, typename P>
+class Loader : public LoaderBase {
+public:
+    using ResultType = std::optional<R>;
+    explicit Loader(ApiClient *apiClient)
+        : LoaderBase(apiClient) {}
+
+    /**
+     * @brief Retrieves the loaded resource. Only valid after the ready signal has been emitted.
+     *
+     * @return The loaded resource.
+     */
+    R result() const {
+        return m_result.value();
+    }
+
+    bool hasResult() const {
+        return m_result;
+    }
     /**
      * @brief Sets the parameters for this loader.
      * @param parameters The parameters to set
@@ -146,26 +159,133 @@ public:
     void setParameters(const P &parameters) {
         m_parameters = parameters;
     }
-protected:
-    Jellyfin::ApiClient *m_apiClient;
-    std::optional<P> m_parameters;
-    std::optional<R> m_result;
-    bool m_isRunning = false;
 
-    void stopWithError(QString message = QString()) {
-        m_isRunning = false;
-        emit this->error(message);
+protected:
+    std::optional<P> m_parameters;
+    ResultType m_result;
+
+    ResultType createFailureResult() {
+        return std::nullopt;
+    }
+
+    ResultType createSuccessResult(R &&result) {
+        return std::make_optional<R>(result);
+    }
+
+    static R createDummyResponse() {
+        return fromJsonValue<R>(QJsonValue());
+    }
+
+};
+
+template <typename P>
+class Loader<void, P> : public LoaderBase {
+public:
+    using ResultType = bool;
+    explicit Loader(ApiClient *apiClient)
+        : LoaderBase(apiClient) {}
+
+    void result() const { }
+
+    bool hasResult() const {
+        return m_result;
+    }
+    /**
+     * @brief Sets the parameters for this loader.
+     * @param parameters The parameters to set
+     *
+     * This method will copy the parameters. The parameters must have a
+     * copy constructor.
+     */
+    void setParameters(const P &parameters) {
+        m_parameters = parameters;
+    }
+
+protected:
+    std::optional<P> m_parameters;
+    ResultType m_result;
+
+    ResultType createFailureResult() {
+        return false;
+    }
+
+    ResultType createSuccessResult(void) {
+        return true;
+    }
+
+    static void createDummyResponse() { }
+};
+
+template<typename R, typename P>
+class HttpLoaderBase : public Loader<R, P> {
+public:
+    explicit HttpLoaderBase(Jellyfin::ApiClient *apiClient)
+        : Loader<R, P> (apiClient) {}
+
+    typename Loader<R, P>::ResultType parseResponse(int /*statusCode*/, QByteArray response) {
+        QJsonParseError error;
+        QJsonDocument document = QJsonDocument::fromJson(response, &error);
+        if (error.error != QJsonParseError::NoError) {
+            qWarning() << response;
+            this->stopWithError(error.errorString().toLocal8Bit().constData());
+        }
+        if (document.isNull() || document.isEmpty()) {
+            this->stopWithError(QStringLiteral("Unexpected empty JSON response"));
+            return this->createFailureResult();
+        } else if (document.isArray()) {
+            return this->createSuccessResult(fromJsonValue<R>(document.array()));
+        } else if (document.isObject()){
+            return this->createSuccessResult(fromJsonValue<R>(document.object()));
+        } else {
+            this->stopWithError(QStringLiteral("Unexpected JSON response"));
+            return this->createFailureResult();
+        }
+    }
+
+};
+
+// Specialisation for void result
+template<typename P>
+class HttpLoaderBase<void, P> : public Loader<void, P> {
+public:
+    explicit HttpLoaderBase(Jellyfin::ApiClient *apiClient)
+        : Loader<void, P> (apiClient) {}
+
+    typename Loader<void, P>::ResultType parseResponse(int statusCode, QByteArray response) {
+        return statusCode == 204;
     }
 };
 
+// Specialisation for endpoints that return "true" or "false" as response.
+template<typename P>
+class HttpLoaderBase<bool, P> : public Loader<bool, P> {
+public:
+    explicit HttpLoaderBase(Jellyfin::ApiClient *apiClient)
+        : Loader<bool, P> (apiClient) {}
+
+    typename Loader<bool, P>::ResultType parseResponse(int statusCode, QByteArray response) {
+        QString text = QString::fromUtf8(response);
+
+        if (text == QStringLiteral("true")) {
+            return true;
+        } else if (text == QStringLiteral("false")) {
+            return false;
+        } else {
+            this->stopWithError(QStringLiteral("Could not parse boolean response: %1").arg(text));
+            return std::nullopt;
+        }
+    }
+};
+
+
 /**
  * Implementation of Loader that loads Items over HTTP
  */
 template <typename R, typename P>
-class HttpLoader : public Loader<R, P> {
+class HttpLoader : public HttpLoaderBase<R, P> {
 public:
     explicit HttpLoader(Jellyfin::ApiClient *apiClient)
-        : Loader<R, P> (apiClient) {
+        : HttpLoaderBase<R, P> (apiClient) {
         this->connect(&m_parsedWatcher, &QFutureWatcher<std::optional<R>>::finished, this, &HttpLoader<R, P>::onResponseParsed);
     }
 
@@ -198,6 +318,7 @@ public:
         if (m_reply->isRunning()) {
             m_reply->abort();
             m_reply->deleteLater();
+            m_reply = nullptr;
         }
     }
 
@@ -220,7 +341,7 @@ protected:
     virtual QNetworkAccessManager::Operation operation() const = 0;
 private:
     QNetworkReply *m_reply = nullptr;
-    QFutureWatcher<std::optional<R>> m_parsedWatcher;
+    QFutureWatcher<typename Loader<R, P>::ResultType> m_parsedWatcher;
 
     void onRequestFinished() {
         if (m_reply->error() != QNetworkReply::NoError) {
@@ -228,38 +349,29 @@ private:
             m_parsedWatcher.cancel();
             //: An HTTP has occurred. First argument is replaced by QNetworkReply->errorString()
             this->stopWithError(QStringLiteral("HTTP error: %1").arg(m_reply->errorString()));
+            return;
         }
         QByteArray array = m_reply->readAll();
+        int statusCode = m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
         m_reply->deleteLater();
         m_reply = nullptr;
-        m_parsedWatcher.setFuture(QtConcurrent::run(this, &HttpLoader<R, P>::parseResponse, array));
-    }
-
-    std::optional<R> parseResponse(QByteArray response) {
-        QJsonParseError error;
-        QJsonDocument document = QJsonDocument::fromJson(response, &error);
-        if (error.error != QJsonParseError::NoError) {
-            qWarning() << response;
-            this->stopWithError(error.errorString().toLocal8Bit().constData());
-        }
-        if (document.isNull() || document.isEmpty()) {
-            this->stopWithError(QStringLiteral("Unexpected empty JSON response"));
-            return std::nullopt;
-        } else if (document.isArray()) {
-            return std::make_optional<R>(fromJsonValue<R>(document.array()));
-        } else if (document.isObject()){
-            return std::make_optional<R>(fromJsonValue<R>(document.object()));
-        } else {
-            this->stopWithError(QStringLiteral("Unexpected JSON response"));
-            return std::nullopt;
-        }
+        m_parsedWatcher.setFuture(
+                    QtConcurrent::run<typename HttpLoader<R, P>::ResultType, // Result
+                                      HttpLoader<R, P>,                      // class
+                                      int, int,                              // Argument 1
+                                      QByteArray, QByteArray>                // Argument 2
+                                        (this, &HttpLoader<R, P>::parseResponse, statusCode, array)
+                    );
     }
 
     void onResponseParsed() {
         Q_ASSERT(m_parsedWatcher.isFinished());
         try {
-            if (m_parsedWatcher.result().has_value()) {
-                this->m_result = m_parsedWatcher.result().value();
+            /* In case the result is an optional, it invokes the bool cast of std::optional, checking
+               if it has a value.
+               In case the result is a boolean, it just checks the boolean */
+            if (m_parsedWatcher.result()) {
+                this->m_result = m_parsedWatcher.result();
                 this->m_isRunning = false;
                 emit this->ready();
             } else {

core/include/JellyfinQt/viewmodel/item.h

@@ -28,6 +28,7 @@
 #include <QDebug>
 #include <QList>
 #include <QObject>
+#include <QQmlListProperty>
 #include <QSharedPointer>
 #include <QUuid>
 
@@ -55,6 +56,51 @@ namespace ViewModel {
 
 class UserData;
 
+namespace {
+    template<typename T>
+    void qqmlistproperty_qlist_append(QQmlListProperty<T> *prop, T *data) {
+        static_cast<QList<T> *>(prop->data())->append(data);
+    }
+
+    template<typename T>
+    void qqmlistproperty_qlist_clear(QQmlListProperty<T> *prop) {
+        static_cast<QList<T> *>(prop->data())->clear();
+    }
+
+    template<typename T>
+    T *qqmlistproperty_qlist_at(QQmlListProperty<T> *prop, qint32 idx) {
+        return &static_cast<QList<T> *>(prop->data())->at(idx);
+    }
+
+    template<typename T>
+    void qqmlistproperty_qlist_count(QQmlListProperty<T> *prop) {
+        static_cast<QList<T> *>(prop->data())->count();
+    }
+}
+
+template <typename T>
+QQmlListProperty<T> qQmlListPropertyFromQList(QObject *object, QList<T> *list) {
+    return QQmlListProperty<T>(object, list, &qqmlistproperty_qlist_append<T>, &qqmlistproperty_qlist_count<T>, &qqmlistproperty_qlist_at<T>, &qqmlistproperty_qlist_clear<T>);
+}
+
+
+class NameGuidPair : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
+    Q_PROPERTY(QString jellyfinId READ jellyfinId NOTIFY jellyfinIdChanged)
+public:
+    explicit NameGuidPair(QSharedPointer<DTO::NameGuidPair> data = QSharedPointer<DTO::NameGuidPair>::create(QStringLiteral("00000000000000000000000000000000")), QObject *parent = nullptr);
+
+    QString name() const { return m_data->name(); }
+    QString jellyfinId() const { return m_data->jellyfinId(); }
+signals:
+    void nameChanged(const QString &newName);
+    void jellyfinIdChanged(const QString &newJellyfinId);
+
+private:
+    QSharedPointer<DTO::NameGuidPair> m_data;
+};
+
 class Item : public QObject {
     Q_OBJECT
 public:
@@ -116,11 +162,22 @@ public:
     Q_PROPERTY(QList<QObject *> subtitleStreams READ subtitleStreams NOTIFY subtitleStreamsChanged)
     Q_PROPERTY(double primaryImageAspectRatio READ primaryImageAspectRatio NOTIFY primaryImageAspectRatioChanged)
     Q_PROPERTY(QStringList artists READ artists NOTIFY artistsChanged)
+    Q_PROPERTY(QList<QObject *> artistItems READ artistItems NOTIFY artistItemsChanged);
+    Q_PROPERTY(QString collectionType READ collectionType NOTIFY collectionTypeChanged)
     // Why is this a QJsonObject? Well, because I couldn't be bothered to implement the deserialisations of
     // a QHash at the moment.
     Q_PROPERTY(QJsonObject imageTags READ imageTags NOTIFY imageTagsChanged)
     Q_PROPERTY(QStringList backdropImageTags READ backdropImageTags NOTIFY backdropImageTagsChanged)
     Q_PROPERTY(QJsonObject imageBlurHashes READ imageBlurHashes NOTIFY imageBlurHashesChanged)
+    Q_PROPERTY(int trailerCount READ trailerCount NOTIFY trailerCountChanged)
+    Q_PROPERTY(int movieCount READ movieCount NOTIFY movieCountChanged)
+    Q_PROPERTY(int seriesCount READ seriesCount NOTIFY seriesCountChanged)
+    Q_PROPERTY(int programCount READ programCount NOTIFY programCountChanged)
+    Q_PROPERTY(int episodeCount READ episodeCount NOTIFY episodeCountChanged)
+    Q_PROPERTY(int songCount READ songCount NOTIFY songCountChanged)
+    Q_PROPERTY(int albumCount READ albumCount NOTIFY albumCountChanged)
+    Q_PROPERTY(int artistCount READ artistCount NOTIFY artistCountChanged)
+    Q_PROPERTY(int musicVideoCount READ musicVideoCount NOTIFY musicVideoCountChanged)
     Q_PROPERTY(QString mediaType READ mediaType READ mediaType NOTIFY mediaTypeChanged)
     Q_PROPERTY(int width READ width NOTIFY widthChanged)
     Q_PROPERTY(int height READ height NOTIFY heightChanged)
@@ -162,10 +219,23 @@ public:
     QObjectList subtitleStreams() const { return m_subtitleStreams; }
     double primaryImageAspectRatio() const { return m_data->primaryImageAspectRatio().value_or(1.0); }
     QStringList artists() const { return m_data->artists(); }
+    QList<QObject *> artistItems() const{ return this->m_artistItems; }
+    QString collectionType() const { return this->m_data->collectionType(); }
     QJsonObject imageTags() const { return m_data->imageTags(); }
     QStringList backdropImageTags() const { return m_data->backdropImageTags(); }
     QJsonObject imageBlurHashes() const { return m_data->imageBlurHashes(); }
     QString mediaType() const { return m_data->mediaType(); }
+
+    int trailerCount() const { return m_data->trailerCount().value_or(0); }
+    int movieCount() const { return m_data->movieCount().value_or(0); }
+    int seriesCount() const { return m_data->seriesCount().value_or(0); }
+    int programCount() const { return m_data->programCount().value_or(0); }
+    int episodeCount() const { return m_data->episodeCount().value_or(0); }
+    int songCount() const { return m_data->songCount().value_or(0); }
+    int albumCount() const { return m_data->albumCount().value_or(0); }
+    int artistCount() const { return m_data->artistCount().value_or(0); }
+    int musicVideoCount() const { return m_data->musicVideoCount().value_or(0); }
+
     int width() const { return m_data->width().value_or(0); }
     int height() const { return m_data->height().value_or(0); }
 
@@ -223,9 +293,20 @@ signals:
     void subtitleStreamsChanged(QVariantList &newSubtitleStreams);
     void primaryImageAspectRatioChanged(double newPrimaryImageAspectRatio);
     void artistsChanged(const QStringList &newArtists);
+    void artistItemsChanged();
+    void collectionTypeChanged();
     void imageTagsChanged();
     void backdropImageTagsChanged();
     void imageBlurHashesChanged();
+    void trailerCountChanged(int newTrailerCount);
+    void movieCountChanged(int newMovieCount);
+    void seriesCountChanged(int newSeriesCount);
+    void programCountChanged(int newProgramCount);
+    void episodeCountChanged(int newEpisodeCount);
+    void songCountChanged(int newSongCount);
+    void albumCountChanged(int newAlbumCount);
+    void artistCountChanged(int newArtistCount);
+    void musicVideoCountChanged(int newMusicVideoCount);
     void mediaTypeChanged(const QString &newMediaType);
     void widthChanged(int newWidth);
     void heightChanged(int newHeight);
@@ -240,6 +321,7 @@ protected:
     QObjectList m_audioStreams;
     QObjectList m_videoStreams;
     QObjectList m_subtitleStreams;
+    QObjectList m_artistItems;
 private slots:
     void onUserDataChanged(const DTO::UserItemDataDto &userData);
 };

core/include/JellyfinQt/viewmodel/itemmodel.h

@@ -290,6 +290,42 @@ public:
     FWDPROP(QString, seriesId, SeriesId)
 };
 
+using AlbumArtistLoaderBase = AbstractUserParameterLoader<Model::Item, DTO::BaseItemDto, DTO::BaseItemDtoQueryResult, Jellyfin::Loader::GetAlbumArtistsParams>;
+class AlbumArtistLoader : public AlbumArtistLoaderBase {
+    Q_OBJECT
+public:
+    explicit AlbumArtistLoader(QObject *parent = nullptr);
+
+    FWDLISTPROP(Jellyfin::DTO::ImageTypeClass::Value, enableImageTypes, EnableImageTypes);
+    FWDPROP(bool, enableImages, EnableImages)
+    FWDPROP(bool, enableTotalRecordCount, EnableTotalRecordCount)
+    FWDPROP(bool, enableUserData, EnableUserData)
+    FWDPROP(QStringList, excludeItemTypes, ExcludeItemTypes)
+    FWDLISTPROP(Jellyfin::DTO::ItemFieldsClass::Value, fields, Fields)
+    FWDLISTPROP(Jellyfin::DTO::ItemFilterClass::Value, filters, Filters)
+    FWDPROP(QStringList, genreIds, GenreIds)
+    FWDPROP(QStringList, genres, Genres)
+    FWDPROP(qint32, imageTypeLimit, ImageTypeLimit)
+    FWDPROP(QStringList, includeItemTypes, IncludeItemTypes)
+    FWDPROP(bool, isFavorite, IsFavorite)
+    FWDPROP(int, limit, Limit)
+    FWDPROP(QStringList, mediaTypes, MediaTypes)
+    FWDPROP(double, minCommunityRating, MinCommunityRating)
+    FWDPROP(QString, nameLessThan, NameLessThan)
+    FWDPROP(QString, nameStartsWith, NameStartsWith)
+    FWDPROP(QString, nameStartsWithOrGreater, NameStartsWithOrGreater)
+    FWDPROP(QStringList, officialRatings, OfficialRatings)
+    FWDPROP(QString, parentId, ParentId)
+    FWDPROP(QStringList, personIds, PersonIds)
+    FWDPROP(QStringList, personTypes, PersonTypes)
+    FWDPROP(QString, searchTerm, SearchTerm)
+    FWDPROP(int, startIndex, StartIndex)
+    FWDPROP(QStringList, studioIds, StudioIds)
+    FWDPROP(QStringList, studios, Studios)
+    FWDPROP(QStringList, tags, Tags)
+    FWDPROP(QString, userId, UserId)
+    FWDLISTPROP(int, years, Years);
+};
 
 /**
  * @brief Base class for each model that works with items.
@@ -319,6 +355,7 @@ public:
         indexNumber,
         runTimeTicks,
         artists,
+        artistItems,
         isFolder,
         overview,
         parentIndexNumber,
@@ -359,6 +396,7 @@ public:
             JFRN(indexNumber),
             JFRN(runTimeTicks),
             JFRN(artists),
+            JFRN(artistItems),
             JFRN(isFolder),
             JFRN(overview),
             JFRN(parentIndexNumber),

core/include/JellyfinQt/viewmodel/playbackmanager.h

@@ -1,6 +1,6 @@
 /*
  * Sailfin: a Jellyfin client written using Qt
- * Copyright (C) 2021 Chris Josten and the Sailfin Contributors.
+ * Copyright (C) 2021-2022 Chris Josten and the Sailfin Contributors.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,11 +20,12 @@
 #define JELLYFIN_VIEWMODEL_PLAYBACKMANAGER_H
 
 #include <QAbstractItemModel>
+#include <QFuture>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QLoggingCategory>
-#include <QFuture>
 #include <QObject>
+#include <QSharedPointer>
 #include <QtGlobal>
 #include <QUrlQuery>
 #include <QVariant>
@@ -34,16 +35,18 @@
 
 #include <functional>
 
-#include "../dto/baseitemdto.h"
-#include "../dto/playbackinfodto.h"
-#include "../dto/playbackinforesponse.h"
-#include "../dto/playmethod.h"
-#include "../loader/requesttypes.h"
-#include "../model/playlist.h"
-#include "../support/jsonconv.h"
-#include "../viewmodel/item.h"
-#include "../viewmodel/playlist.h"
-#include "../apiclient.h"
+#include <JellyfinQt/dto/baseitemdto.h>
+#include <JellyfinQt/dto/playbackinfodto.h>
+#include <JellyfinQt/dto/playbackinforesponse.h>
+#include <JellyfinQt/dto/playmethod.h>
+#include <JellyfinQt/loader/requesttypes.h>
+#include <JellyfinQt/model/controllablesession.h>
+#include <JellyfinQt/model/player.h>
+#include <JellyfinQt/model/playlist.h>
+#include <JellyfinQt/support/jsonconv.h>
+#include <JellyfinQt/viewmodel/item.h>
+#include <JellyfinQt/viewmodel/playlist.h>
+#include <JellyfinQt/apiclient.h>
 #include "itemmodel.h"
 
 
@@ -60,34 +63,44 @@ class PlaystateRequest;
 namespace ViewModel {
 Q_DECLARE_LOGGING_CATEGORY(playbackManager);
 
-// Later defined in this file
-class ItemUrlFetcherThread;
+class PlaybackManagerPrivate;
 
 /**
- * @brief The PlaybackManager class manages the playback of Jellyfin items. It fetches streams based on Jellyfin items, posts
- * the current playback state to the Jellyfin Server, contains the actual media player and so on.
+ * @brief The PlaybackManager class manages the playback of Jellyfin items.
  *
- * The PlaybackManager actually keeps two mediaPlayers, m_mediaPlayer1 and m_mediaPlayer2. When one is playing, the other is
- * preloading the next item in the queue. The current media player is pointed to by m_mediaPlayer.
+ * It is a small wrapper around an instance of Jellyfin::Model::PlaybackManager,
+ * which do the actual work. The Jellyfin::Model::PlaybackManager can be switched
+ * on the fly, allowing this class to switch between controlling the playback locally
+ * or remote.
  */
 class PlaybackManager : public QObject, public QQmlParserStatus {
-    friend class ItemUrlFetcherThread;
     Q_OBJECT
+    Q_DECLARE_PRIVATE(PlaybackManager);
     Q_INTERFACES(QQmlParserStatus)
 public:
-    using ItemUrlLoader = Support::Loader<DTO::PlaybackInfoResponse, Jellyfin::Loader::GetPostedPlaybackInfoParams>;
 
     explicit PlaybackManager(QObject *parent = nullptr);
+    virtual ~PlaybackManager();
 
-    Q_PROPERTY(ApiClient *apiClient MEMBER m_apiClient WRITE setApiClient)
+    Q_PROPERTY(ApiClient *apiClient READ apiClient WRITE setApiClient)
+    Q_PROPERTY(QString controllingSessionId READ controllingSessionId NOTIFY controllingSessionIdChanged)
+    Q_PROPERTY(QString controllingSessionName READ controllingSessionName NOTIFY controllingSessionNameChanged)
+    /**
+     * Whether the playback is done by this client
+     */
+    Q_PROPERTY(bool controllingSessionLocal READ controllingSessionLocal NOTIFY controllingSessionLocalChanged)
+
+    Q_PROPERTY(int audioIndex READ audioIndex WRITE setAudioIndex NOTIFY audioIndexChanged)
+    Q_PROPERTY(int subtitleIndex READ subtitleIndex WRITE setSubtitleIndex NOTIFY subtitleIndexChanged)
     Q_PROPERTY(QString streamUrl READ streamUrl NOTIFY streamUrlChanged)
-    Q_PROPERTY(bool autoOpen MEMBER m_autoOpen NOTIFY autoOpenChanged)
-    Q_PROPERTY(int audioIndex MEMBER m_audioIndex NOTIFY audioIndexChanged)
-    Q_PROPERTY(int subtitleIndex MEMBER m_subtitleIndex NOTIFY subtitleIndexChanged)
-    Q_PROPERTY(bool resumePlayback MEMBER m_resumePlayback NOTIFY resumePlaybackChanged)
+    //Q_PROPERTY(bool autoOpen MEMBER m_autoOpen NOTIFY autoOpenChanged)
+    /**
+     * Whether the player should resume playback.
+     */
+    Q_PROPERTY(bool resumePlayback READ resumePlayback WRITE setResumePlayback NOTIFY resumePlaybackChanged)
     Q_PROPERTY(Jellyfin::DTO::PlayMethodClass::Value playMethod READ playMethod NOTIFY playMethodChanged)
 
-    // Current Item and queue informatoion
+    // Current Item and queue information
     Q_PROPERTY(QObject *item READ item NOTIFY itemChanged)
     Q_PROPERTY(int queueIndex READ queueIndex NOTIFY queueIndexChanged)
     Q_PROPERTY(Jellyfin::ViewModel::Playlist *queue READ queue NOTIFY queueChanged)
@@ -98,42 +111,59 @@ public:
     Q_PROPERTY(QString errorString READ errorString NOTIFY errorStringChanged)
     Q_PROPERTY(bool hasVideo READ hasVideo NOTIFY hasVideoChanged)
     Q_PROPERTY(bool seekable READ seekable NOTIFY seekableChanged)
-    Q_PROPERTY(QObject* mediaObject READ mediaObject NOTIFY mediaObjectChanged)
-    Q_PROPERTY(QMediaPlayer::MediaStatus mediaStatus READ mediaStatus NOTIFY mediaStatusChanged)
-    Q_PROPERTY(QMediaPlayer::State playbackState READ playbackState NOTIFY playbackStateChanged)
+    Q_PROPERTY(QObject* mediaObject READ mediaObject NOTIFY mediaObjectChanged);
+    Q_PROPERTY(Jellyfin::Model::MediaStatusClass::Value mediaStatus READ mediaStatus NOTIFY mediaStatusChanged)
+    Q_PROPERTY(Jellyfin::Model::PlayerStateClass::Value playbackState READ playbackState NOTIFY playbackStateChanged)
     Q_PROPERTY(qint64 position READ position NOTIFY positionChanged)
     Q_PROPERTY(bool hasNext READ hasNext NOTIFY hasNextChanged)
     Q_PROPERTY(bool hasPrevious READ hasPrevious NOTIFY hasPreviousChanged)
     /// Whether playstate commands received over the websocket should be handled
     Q_PROPERTY(bool handlePlaystateCommands READ handlePlaystateCommands WRITE setHandlePlaystateCommands NOTIFY handlePlaystateCommandsChanged)
 
-    ViewModel::Item *item() const { return m_displayItem; }
-    QSharedPointer<Model::Item> dataItem() const { return m_item; }
-    ApiClient *apiClient() const { return m_apiClient; }
+    // R/W props
+    ApiClient *apiClient() const;
     void setApiClient(ApiClient *apiClient);
+    bool resumePlayback() const;
+    void setResumePlayback(bool newResumePlayback);
+    int audioIndex() const;
+    void setAudioIndex(int newAudioIndex);
+    int subtitleIndex() const;
+    void setSubtitleIndex(int newAudioIndex);
 
-    QString streamUrl() const { return m_streamUrl; }
-    PlayMethod playMethod() const { return m_playMethod; }
-    QObject *mediaObject() const { return m_mediaPlayer; }
-    qint64 position() const { return m_mediaPlayer->position(); }
-    qint64 duration() const { return m_mediaPlayer->duration(); }
-    ViewModel::Playlist *queue() const { return m_displayQueue; }
-    int queueIndex() const { return m_queueIndex; }
-    bool hasNext() const { return m_queue->hasNext(); }
-    bool hasPrevious() const { return m_queue->hasPrevious(); }
+    ViewModel::Item *item() const;
+    QSharedPointer<Model::Item> dataItem() const;
+
+    QSharedPointer<Model::ControllableSession> controllingSession() const;
+    void setControllingSession(QSharedPointer<Model::ControllableSession> session);
+    QString controllingSessionId() const;
+    QString controllingSessionName() const;
+    bool controllingSessionLocal() const;
+    QString streamUrl() const;
+    PlayMethod playMethod() const;
+    qint64 position() const;
+    qint64 duration() const;
+    ViewModel::Playlist *queue() const;
+    int queueIndex() const;
+    bool hasNext() const;
+    bool hasPrevious() const;
 
     // Current media player related property getters
-    QMediaPlayer::State playbackState() const { return m_playbackState; }
-    QMediaPlayer::MediaStatus mediaStatus() const { return m_mediaPlayer->mediaStatus(); }
-    bool hasVideo() const { return m_mediaPlayer->isVideoAvailable(); }
-    bool seekable() const { return m_mediaPlayer->isSeekable(); }
+    QObject* mediaObject() const;
+    Model::PlayerState playbackState() const;
+    Model::MediaStatus mediaStatus() const;
+    bool hasVideo() const;
+    bool seekable() const;
     QMediaPlayer::Error error () const;
     QString errorString() const;
 
-    bool handlePlaystateCommands() const { return m_handlePlaystateCommands; }
-    void setHandlePlaystateCommands(bool newHandlePlaystateCommands) { m_handlePlaystateCommands = newHandlePlaystateCommands; emit handlePlaystateCommandsChanged(m_handlePlaystateCommands); }
+    bool handlePlaystateCommands() const;
+    void setHandlePlaystateCommands(bool newHandlePlaystateCommands);
 signals:
-    void itemChanged(ViewModel::Item *newItemId);
+    void itemChanged();
+    void controllingSessionChanged();
+    void controllingSessionIdChanged();
+    void controllingSessionNameChanged();
+    void controllingSessionLocalChanged();
     void streamUrlChanged(const QString &newStreamUrl);
     void autoOpenChanged(bool autoOpen);
     void audioIndexChanged(int audioIndex);
@@ -145,20 +175,21 @@ signals:
     // Emitted when seek has been called.
     void seeked(qint64 newPosition);
 
+    void hasNextChanged(bool newHasNext);
+    void hasPreviousChanged(bool newHasPrevious);
+
     // Current media player related property signals
-    void mediaObjectChanged(QObject *newMediaObject);
+    void mediaObjectChanged(QObject *newPlayer);
     void positionChanged(qint64 newPosition);
     void durationChanged(qint64 newDuration);
     void queueChanged(QAbstractItemModel *newQueue);
     void queueIndexChanged(int newIndex);
-    void playbackStateChanged(QMediaPlayer::State newState);
-    void mediaStatusChanged(QMediaPlayer::MediaStatus newMediaStatus);
+    void playbackStateChanged(Jellyfin::Model::PlayerStateClass::Value newState);
+    void mediaStatusChanged(Jellyfin::Model::MediaStatusClass::Value newMediaStatus);
     void hasVideoChanged(bool newHasVideo);
     void seekableChanged(bool newSeekable);
     void errorChanged(QMediaPlayer::Error newError);
     void errorStringChanged(const QString &newErrorString);
-    void hasNextChanged(bool newHasNext);
-    void hasPreviousChanged(bool newHasPrevious);
     void handlePlaystateCommandsChanged(bool newHandlePlaystateCommands);
 public slots:
     /**
@@ -187,7 +218,7 @@ public slots:
      */
     void skipToItemIndex(int index);
     void play();
-    void pause() { m_mediaPlayer->pause(); setPlaybackState(QMediaPlayer::PausedState); }
+    void pause();
     void seek(qint64 pos);
     void stop();
 
@@ -204,105 +235,21 @@ public slots:
     void handlePlaystateRequest(const DTO::PlaystateRequest &request);
 
 private slots:
-    void mediaPlayerStateChanged(QMediaPlayer::State newState);
-    void mediaPlayerPositionChanged(qint64 position);
-    void mediaPlayerMediaStatusChanged(QMediaPlayer::MediaStatus newStatus);
-    void mediaPlayerError(QMediaPlayer::Error error);
-    void mediaPlayerDurationChanged(qint64 newDuration);
-    void mediaPlayerSeekableChanged(bool seekable);
-    /**
-     * @brief updatePlaybackInfo Updates the Jellyfin server with the current playback progress etc.
-     */
-    void updatePlaybackInfo();
-
-    /// Called when we have fetched the playback URL and playSession
-    void onItemUrlReceived(const QString &itemId, const QUrl &url, const QString &playSession,
-                                 // Fully specify class to please MOC
-                                 Jellyfin::DTO::PlayMethodClass::Value playMethod);
-    /// Called when we have encountered an error
-    void onItemErrorReceived(const QString &itemId, const QString &errorString);
-
+    void mediaPlayerItemChanged();
 private:
     /// Factor to multiply with when converting from milliseconds to ticks.
     const static int MS_TICK_FACTOR = 10000;
-    enum PlaybackInfoType { Started, Stopped, Progress };
 
-    /// Timer used to update the play progress on the Jellyfin server
-    QTimer m_updateTimer;
-    /// Timer used to notify ourselves when we need to preload the next item
-    QTimer m_preloadTimer;
 
-    ApiClient *m_apiClient = nullptr;
-    /// The currently playing item
-    QSharedPointer<Model::Item> m_item;
-    /// The item that will be played next
-    QSharedPointer<Model::Item> m_nextItem;
-    /// The currently played item that will be shown in the GUI
-    ViewModel::Item *m_displayItem = new ViewModel::Item(this);
-    /// The currently played queue that will be shown in the GUI
-    ViewModel::Playlist *m_displayQueue = nullptr;
 
-    // Properties for making the streaming request.
-    QString m_streamUrl;
-    QString m_nextStreamUrl;
-    QString m_playSessionId;
-    QString m_nextPlaySessionId;
-    QString m_errorString;
     QMediaPlayer::Error m_error = QMediaPlayer::NoError;
-    /// The index of the mediastreams of the to-be-played item containing the audio
-    int m_audioIndex = 0;
-    /// The index of the mediastreams of the to-be-played item containing subtitles
-    int m_subtitleIndex = -1;
-    /// The position in ticks to resume playback from
-    qint64 m_resumePosition = 0;
-    /// The position in ticks the playback was stopped
-    qint64 m_stopPosition = 0;
-
-    /// Keeps track of latest playback position
-    qint64 m_oldPosition = 0;
-    /**
-     * @brief Whether to automatically open the livestream of the item;
-     */
-    bool m_autoOpen = false;
-
-    bool m_seekToResumedPosition = false;
-
-    QMediaPlayer::State m_oldState = QMediaPlayer::StoppedState;
-    /// State of the playbackManager. While the internal media player stops after a
-    /// song has ended, this will not do so.
-    QMediaPlayer::State m_playbackState = QMediaPlayer::StoppedState;
-    PlayMethod m_playMethod = PlayMethod::Transcode;
-    /// Pointer to the current media player.
-    QMediaPlayer *m_mediaPlayer = nullptr;
-
-    Model::Playlist *m_queue = nullptr;
-    int m_queueIndex = 0;
-    bool m_resumePlayback = false;
-    bool m_handlePlaystateCommands = true;
-
-    // Helper methods
-    void setItem(QSharedPointer<Model::Item> newItem);
-
-    void setStreamUrl(const QUrl &streamUrl);
-    void setPlaybackState(QMediaPlayer::State newState);
-
-    /**
-     * @brief Posts the playback information
-     */
-    void postPlaybackInfo(PlaybackInfoType type);
-
-    void requestItemUrl(QSharedPointer<Model::Item> item);
-    void handlePlaybackInfoResponse(QString itemId, QString mediaType, DTO::PlaybackInfoResponse &response);
-
 
     // QQmlParserListener interface
     void classBegin() override { m_qmlIsParsingComponent = true; }
     void componentComplete() override;
     bool m_qmlIsParsingComponent = false;
 
-    /// Time in ms at what moment this playbackmanager should start loading the next item.
-    const qint64 PRELOAD_DURATION = 15 * 1000;
-    QTimer m_forceSeekTimer;
+    QScopedPointer<PlaybackManagerPrivate> d_ptr;
 };
 
 } // NS ViewModel

core/include/JellyfinQt/viewmodel/playlist.h

@@ -59,6 +59,7 @@ public:
         // Item properties
         name = Qt::UserRole + 1,
         artists,
+        artistItems,
         runTimeTicks,
 
         // Non-item properties
@@ -70,6 +71,7 @@ public:
     QVariant data(const QModelIndex &parent, int role = Qt::DisplayRole) const override;
     int rowCount(const QModelIndex &parent) const override;
     QHash<int, QByteArray> roleNames() const override;
+    void setPlaylistModel(Model::Playlist *data);
 
 
 private slots:

core/include/JellyfinQt/viewmodel/remotedevice.h

@@ -0,0 +1,118 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2022 Chris Josten and the Sailfin Contributors.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef JELLYFIN_VIEWMODEL_REMOTEDEVICE_H
+#define JELLYFIN_VIEWMODEL_REMOTEDEVICE_H
+
+#include <JellyfinQt/model/controllablesession.h>
+
+#include <QAbstractItemModel>
+#include <QList>
+#include <QObject>
+#include <QQmlParserStatus>
+#include <QSharedPointer>
+
+#include <utility>
+
+namespace Jellyfin {
+
+class ApiClient;
+
+namespace ViewModel {
+
+class PlaybackManager;
+
+/**
+ * @brief AbstractListModel of remotely controllable devices by JellyfinQt.
+ *
+ * This class controls a set of \link ViewModel::RemoteSessionScanner RemoteSessionScanners\endlink and
+ * puts their found devices in this list.
+ */
+class RemoteDeviceList : public QAbstractListModel, public QQmlParserStatus {
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+
+    /**
+     * The ApiClient for interacting with the Jellyfin API.
+     */
+    Q_PROPERTY(Jellyfin::ApiClient* apiClient READ apiClient WRITE setApiClient NOTIFY apiClientChanged)
+    /**
+     * Gets/sets whether the model is scanning for other devices.
+     */
+    Q_PROPERTY(bool scanning READ scanning WRITE setScanning NOTIFY scanningChanged);
+public:
+    enum RoleNames {
+        jellyfinId = Qt::UserRole + 1,
+        name,
+        deviceName,
+        deviceType,
+        userName,
+        session
+    };
+
+    explicit RemoteDeviceList(QObject *parent = nullptr);
+
+    ApiClient *apiClient() const { return m_apiClient; }
+    void setApiClient(ApiClient *apiClient);
+
+    bool scanning() const { return m_scanning; }
+    void setScanning(bool scanning);
+
+    // QAbstractListModel
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    QHash<int, QByteArray> roleNames() const override {
+        return {
+            { RoleNames::jellyfinId, "jellyfinId"},
+            { RoleNames::name,       "name"       },
+            { RoleNames::deviceName, "deviceName" },
+            { RoleNames::deviceType, "deviceType" },
+            { RoleNames::userName,   "userName"   },
+            { RoleNames::session,    "session"    }
+        };
+    }
+
+    /**
+     * @brief Sets the PlaybackManager to control the session at the given index in this model
+     * @param manager The PlaybackManager
+     * @param index The index of the session that should be controlled
+     */
+    Q_INVOKABLE void activateSession(Jellyfin::ViewModel::PlaybackManager *manager, int index);
+
+    // QQmlParserStatus
+    void classBegin() override;
+    void componentComplete() override;
+signals:
+    void apiClientChanged();
+    void scanningChanged();
+private slots:
+    void onSessionFound(Jellyfin::Model::ControllableSession * session);
+    void onSessionLost(QString sessionId);
+    void onSessionsReset();
+private:
+    ApiClient *m_apiClient = nullptr;
+    bool m_scanning = false;
+    bool m_componentComplete = false;
+    QList<std::pair<Model::RemoteSessionScanner *, QSharedPointer<Model::ControllableSession>>> m_sessions;
+    QList<Model::RemoteSessionScanner *> m_scanners;
+};
+
+} // NS ViewModel
+} // NS Jellyfin
+
+#endif // JELLYFIN_VIEWMODEL_REMOTEDEVICE_H

core/include/JellyfinQt/viewmodel/usermodel.h

@@ -43,17 +43,17 @@ public:
         userId = Qt::UserRole + 1,
         name,
         hasPassword,
-        primaryImageTag,
+        primaryImageTag
     };
 
     explicit UserModel (QObject *parent = nullptr);
 
     virtual QHash<int, QByteArray> roleNames() const override {
         return {
-            { RoleNames::userId,                    "userId"                    },
-            { RoleNames::name,                      "name"                      },
-            { RoleNames::hasPassword,               "hasPassword"               },
-            { RoleNames::primaryImageTag,           "primaryImageTag"           },
+            { RoleNames::userId,                    "userId"          },
+            { RoleNames::name,                      "name"            },
+            { RoleNames::hasPassword,               "hasPassword"     },
+            { RoleNames::primaryImageTag,           "primaryImageTag" }
         };
     }
     QVariant data(const QModelIndex &index, int role) const override;

core/include/JellyfinQt/viewmodel/utils.h

@@ -0,0 +1,78 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2022 Chris Josten and the Sailfin Contributors.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef JELLYFIN_VIEWMODEL_UTILS_H
+#define JELLYFIN_VIEWMODEL_UTILS_H
+
+#include <QObject>
+#include <QSharedPointer>
+#include <QVariant>
+
+/**
+ * \brief Wraps a data object in a QObject.
+ *
+ * This class is made for use in the ViewModel namespace, since many
+ * objects follow the pattern of having a constructor with a QSharedPointer<DTO::SomeItem>
+ * and a parent.
+ *
+ * The QObject wrapper class W must have a accessible constructor which takes only a QSharedPointer<D>
+ * as argument.
+ *
+ * \tparam W The QObject wrapper class
+ * \tparam D The DTO class
+ * \param data The data to wrap in a QObject
+ * \param parent The QObject to set as the parent of the newly created type.
+ */
+template<typename W, typename D>
+W *wrapQObject(D data, QObject *parent) {
+    return new W(QSharedPointer<D>::create(data), parent);
+}
+
+/**
+ * \brief Wraps a list of DTO items in a QVariantList of QObject's
+ * \see wrapQObject()
+ * \param begin The begin iterator of the list of DTO items
+ * \param end The end iterator of the list of DTO items
+ * \param parent The QObject to set as the parent of the QObjects in the newly created list.
+ */
+template<typename W, typename D, typename It>
+QVariantList wrapQVariantList(It begin, It end, QObject *parent) {
+    QVariantList result;
+    for (It it = begin; it != end; it++) {
+        result.append(QVariant::fromValue(wrapQObject<W, D>(*it, parent)));
+    }
+    return result;
+}
+
+/**
+ * \brief Wraps a list of DTO items in a QObjectList.
+ * \see wrapQObject()
+ * \param begin The begin iterator of the list of DTO items
+ * \param end The end iterator of the list of DTO items
+ * \param parent The QObject to set as the parent of the QObjects in the newly created list.
+ */
+template<typename W, typename D, typename It>
+QObjectList wrapQObjectList(It begin, It end, QObject *parent) {
+    QObjectList result;
+    for (It it = begin; it != end; it++) {
+        result.append(wrapQObject<W, D>(*it, parent));
+    }
+    return result;
+}
+
+#endif // JELLYFIN_VIEWMODEL_UTILS_H

core/include/JellyfinQt/websocket.h

@@ -60,9 +60,30 @@ public:
      */
     explicit WebSocket(ApiClient *client);
     enum MessageType {
+        /**
+         * @brief Server to client: instruct client to send periodical KeepAlive messages
+         */
         ForceKeepAlive,
+        /**
+         * @brief Client to server: keep the connection alive
+         */
         KeepAlive,
-        UserDataChanged
+        /**
+         * @brief Server to client: user data for an item has changed.
+         */
+        UserDataChanged,
+        /**
+         * @brief Client to server: Subscribe to playback update sessions.
+         */
+        SessionsStart,
+        /**
+         * @brief Client to server: unsubscribe from playback session updates
+         */
+        SessionsStop,
+        /**
+         * @brief Server to client: session information has changed
+         */
+        Sessions
     };
     Q_PROPERTY(QAbstractSocket::SocketState state READ state NOTIFY stateChanged)
     Q_ENUM(MessageType)
@@ -72,6 +93,8 @@ public:
     }
 public slots:
     void open();
+    void subscribeToSessionInfo();
+    void unsubscribeToSessionInfo();
 private slots:
     void textMessageReceived(const QString &message);
     void onConnected();
@@ -80,7 +103,7 @@ private slots:
     void sendKeepAlive();
     void onWebsocketStateChanged(QAbstractSocket::SocketState newState) { emit stateChanged(newState); }
 signals:
-    void commandReceived(QString arts, QVariantMap args);
+    void commandReceived(QString command, QVariantMap args);
     void stateChanged(QAbstractSocket::SocketState newState);
 
 protected:
@@ -90,6 +113,7 @@ protected:
     QTimer m_keepAliveTimer;
     QTimer m_retryTimer;
     int m_reconnectAttempt = 0;
+    int m_sessionInfoSubscribeCount = 0;
 
 
     void setupKeepAlive(int data);

core/openapi.json

@@ -34508,6 +34508,41 @@
               "format": "int64",
               "nullable": true
             }
+          },
+          {
+            "name": "mediaSourceId",
+            "in": "query",
+            "description": "Optional. The media source id.",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "audioStreamIndex",
+            "in": "query",
+            "description": "Optional. The index of the audio stream to play.",
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          },
+          {
+            "name": "subtitleStreamIndex",
+            "in": "query",
+            "description": "Optional. The index of the subtitle stream to play.",
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          },
+          {
+            "name": "startIndex",
+            "in": "query",
+            "description": "Optional. The start index.",
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
           }
         ],
         "responses": {
@@ -55377,4 +55412,4 @@
       }
     }
   }
-}
+}

core/openapigenerator.d

@@ -457,7 +457,11 @@ void generateFileForEndpoints(ref const Node[] endpointNodes,
 						}
 					}
 				}
-				}
+			}
+			if (codeNo == 204 /* No content */) {
+				endpoint.resultType = "void";
+				endpoint.hasSuccessResponse = true;
+			}
 		}
 		
 		if ("requestBody" in endpointNode) {

core/src/apiclient.cpp

@@ -22,6 +22,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #include <QSharedPointer>
 
 #include "JellyfinQt/dto/clientcapabilitiesdto.h"
+#include "JellyfinQt/loader/http/quickconnect.h"
 #include "JellyfinQt/support/jsonconv.h"
 #include "JellyfinQt/viewmodel/settings.h"
 #include "JellyfinQt/websocket.h"
@@ -44,8 +45,10 @@ public:
     // Authentication-related variables
     QString token;
     QString baseUrl;
+    QString appName;
     QString deviceName;
     QString deviceId;
+    Model::DeviceType deviceType = Model::DeviceType::Unknown;
     QString userId;
 
     bool online = true;
@@ -103,6 +106,21 @@ void ApiClient::setBaseUrl(const QString &url) {
     emit this->baseUrlChanged(d->baseUrl);
 }
 
+const QString &ApiClient::appName() const {
+    const Q_D(ApiClient);
+    return d->appName;
+}
+
+void ApiClient::setAppName(const QString &name) {
+    Q_D(ApiClient);
+    d->appName = name;
+    emit appNameChanged(name);
+
+    if (!d->componentBeingParsed) {
+        generateDeviceProfile();
+    }
+}
+
 const QString &ApiClient::userId() const {
     Q_D(const ApiClient);
     return d->userId;
@@ -119,6 +137,17 @@ const QString &ApiClient::deviceId() const {
     return d->deviceId;
 }
 
+Model::DeviceType ApiClient::deviceType() const {
+    Q_D(const ApiClient);
+    return d->deviceType;
+}
+
+void ApiClient::setDeviceType(Model::DeviceType newDeviceType) {
+    Q_D(ApiClient);
+    d->deviceType =newDeviceType;
+    emit deviceTypeChanged();
+}
+
 EventBus *ApiClient::eventbus() const {
     Q_D(const ApiClient);
     return d->eventbus;
@@ -220,7 +249,7 @@ void ApiClient::addBaseRequestHeaders(QNetworkRequest &request, const QString &p
 void ApiClient::addTokenHeader(QNetworkRequest &request) const {
     Q_D(const ApiClient);
     QString authentication =   "MediaBrowser ";
-    authentication        +=   "Client=\"Sailfin\"";
+    authentication        +=   "Client=\"" +d->appName +"\"";
     authentication        += ", Device=\"" + d->deviceName + "\"";
     authentication        += ", DeviceId=\"" + d->deviceId + "\"";
     authentication        += ", Version=\"" + version() + "\"";
@@ -400,6 +429,26 @@ void ApiClient::authenticate(QString username, QString password, bool storeCrede
     setDefaultErrorHandler(rep);
 }
 
+void ApiClient::submitQuickConnectCode(const QString &code) {
+    using QQAuthorizeLoader = Loader::HTTP::AuthorizeLoader;
+    Loader::AuthorizeParams params;
+    params.setCode(code);
+
+    QQAuthorizeLoader *loader = new QQAuthorizeLoader(this);
+    loader->setParameters(params);
+    loader->load();
+
+    loader->connect(loader, &QQAuthorizeLoader::error, this, [this, loader](QString message) {
+        qDebug() << "QQ error: " << message;
+        emit this->quickConnectRejected();
+        loader->deleteLater();
+    });
+    loader->connect(loader, &QQAuthorizeLoader::ready, this, [this, loader]() {
+        emit this->quickConnectAccepted();
+        loader->deleteLater();
+    });
+}
+
 void ApiClient::deleteSession() {
     QNetworkReply *rep = post("/Sessions/Logout");
     connect(rep, &QNetworkReply::finished, this, [rep, this] {
@@ -425,7 +474,6 @@ QString ApiClient::downloadUrl(const QString &itemId) const {
 void ApiClient::generateDeviceProfile() {
     Q_D(ApiClient);
     QSharedPointer<DTO::DeviceProfile> deviceProfile = QSharedPointer<DTO::DeviceProfile>::create(Model::DeviceProfile::generateProfile());
-    deviceProfile->setName(d->deviceName);
     deviceProfile->setJellyfinId(d->deviceId);
     deviceProfile->setFriendlyName(QSysInfo::prettyProductName());
     deviceProfile->setMaxStreamingBitrate(d->settings->maxStreamingBitRate());

core/src/apimodel.cpp

@@ -150,7 +150,7 @@ void setRequestLimit(Loader::GetItemsByUserIdParams &params, int limit) {
 
 template<>
 bool setRequestStartIndex(Loader::GetItemsByUserIdParams &params, int index) {
-    params.setLimit(index);
+    params.setStartIndex(index);
     return true;
 }
 
@@ -161,7 +161,7 @@ void setRequestLimit(Loader::GetResumeItemsParams &params, int limit) {
 
 template<>
 bool setRequestStartIndex(Loader::GetResumeItemsParams &params, int index) {
-    params.setLimit(index);
+    params.setStartIndex(index);
     return true;
 }
 
@@ -174,6 +174,26 @@ bool setRequestStartIndex(Loader::GetPublicUsersParams &/*params*/, int /*offset
     return false;
 }
 
+template<>
+void setRequestLimit(Loader::GetNextUpParams &params, int limit) {
+    params.setLimit(limit);
+}
+template<>
+bool setRequestStartIndex(Loader::GetNextUpParams &params, int offset) {
+    params.setStartIndex(offset);
+    return true;
+}
+
+template<>
+void setRequestLimit(Loader::GetAlbumArtistsParams &params, int limit) {
+    params.setLimit(limit);
+}
+template<>
+bool setRequestStartIndex(Loader::GetAlbumArtistsParams &params, int offset) {
+    params.setStartIndex(offset);
+    return true;
+}
+
 template<>
 QList<DTO::UserDto> extractRecords(const QList<DTO::UserDto> &result) {
     return result;

core/src/jellyfin.cpp

@@ -30,6 +30,8 @@
 #include "JellyfinQt/eventbus.h"
 #include "JellyfinQt/serverdiscoverymodel.h"
 #include "JellyfinQt/websocket.h"
+#include "JellyfinQt/model/controllablesession.h"
+#include "JellyfinQt/model/player.h"
 #include "JellyfinQt/viewmodel/item.h"
 #include "JellyfinQt/viewmodel/itemmodel.h"
 #include "JellyfinQt/viewmodel/loader.h"
@@ -38,6 +40,7 @@
 #include "JellyfinQt/viewmodel/platformmediacontrol.h"
 #include "JellyfinQt/viewmodel/playbackmanager.h"
 #include "JellyfinQt/viewmodel/playlist.h"
+#include "JellyfinQt/viewmodel/remotedevice.h"
 #include "JellyfinQt/viewmodel/settings.h"
 #include "JellyfinQt/viewmodel/userdata.h"
 #include "JellyfinQt/viewmodel/usermodel.h"
@@ -54,6 +57,7 @@ void JellyfinPlugin::registerTypes(const char *uri) {
     qmlRegisterUncreatableType<ViewModel::User>(uri, 1, 0, "User", "Acquire one via UserLoader or exposed properties");
     qmlRegisterUncreatableType<EventBus>(uri, 1, 0, "EventBus", "Obtain one via your ApiClient");
     qmlRegisterUncreatableType<WebSocket>(uri, 1, 0, "WebSocket", "Obtain one via your ApiClient");
+    qmlRegisterUncreatableType<ViewModel::NameGuidPair>(uri, 1, 0, "NameGuidPair", "Obbtain one via an Item");
     qmlRegisterUncreatableType<ViewModel::MediaStream>(uri, 1, 0, "MediaStream", "Obtain one via an Item");
     qmlRegisterUncreatableType<ViewModel::Settings>(uri, 1, 0, "Settings", "Obtain one via your ApiClient");
     qmlRegisterUncreatableType<ViewModel::UserData>(uri, 1, 0, "UserData", "Obtain one via an Item");
@@ -64,6 +68,7 @@ void JellyfinPlugin::registerTypes(const char *uri) {
     qmlRegisterType<ViewModel::ItemModel>(uri, 1, 0, "ItemModel");
     qmlRegisterType<ViewModel::UserModel>(uri, 1, 0, "UserModel");
     qmlRegisterUncreatableType<ViewModel::Playlist>(uri, 1, 0, "Playlist", "Available via PlaybackManager");
+    qmlRegisterType<ViewModel::RemoteDeviceList>(uri, 1, 0, "RemoteDeviceList");
 
     // Loaders
     qmlRegisterUncreatableType<ViewModel::LoaderBase>(uri, 1, 0, "LoaderBase", "Use one of its subclasses");
@@ -77,6 +82,7 @@ void JellyfinPlugin::registerTypes(const char *uri) {
     qmlRegisterType<ViewModel::ShowEpisodesLoader>(uri, 1, 0, "ShowEpisodesLoader");
     qmlRegisterType<ViewModel::NextUpLoader>(uri, 1, 0, "NextUpLoader");
     qmlRegisterType<ViewModel::PublicUsersLoader>(uri, 1, 0, "PublicUsersLoader");
+    qmlRegisterType<ViewModel::AlbumArtistLoader>(uri, 1, 0, "AlbumArtistLoader");
 
     // Enumerations
     qmlRegisterUncreatableType<Jellyfin::DTO::GeneralCommandTypeClass>(uri, 1, 0, "GeneralCommandType", "Is an enum");
@@ -85,6 +91,9 @@ void JellyfinPlugin::registerTypes(const char *uri) {
     qmlRegisterUncreatableType<Jellyfin::DTO::ItemFieldsClass>(uri, 1, 0, "ItemFields", "Is an enum");
     qmlRegisterUncreatableType<Jellyfin::DTO::ImageTypeClass>(uri, 1, 0, "ImageType", "Is an enum");
     qmlRegisterUncreatableType<Jellyfin::ViewModel::NowPlayingSection>(uri, 1, 0, "NowPlayingSection", "Is an enum");
+    qmlRegisterUncreatableType<Jellyfin::Model::PlayerStateClass>(uri, 1, 0, "PlayerState", "Is an enum");
+    qmlRegisterUncreatableType<Jellyfin::Model::MediaStatusClass>(uri, 1, 0, "MediaStatus", "Is an enum");
+    qmlRegisterUncreatableType<Jellyfin::Model::DeviceTypeClass>(uri, 1, 0, "DeviceType", "Is an enum");
 
     qRegisterMetaType<Jellyfin::DTO::PlayMethodClass::Value>();
 }

core/src/loader/http/apikey.cpp

@@ -64,6 +64,65 @@ QNetworkAccessManager::Operation GetKeysLoader::operation() const {
 
 }
 
+CreateKeyLoader::CreateKeyLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CreateKeyParams>(apiClient) {}
+
+QString CreateKeyLoader::path(const CreateKeyParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Auth/Keys");
+}
+
+QUrlQuery CreateKeyLoader::query(const CreateKeyParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("app", Support::toString<QString>(params.app()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CreateKeyLoader::body(const CreateKeyParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation CreateKeyLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+RevokeKeyLoader::RevokeKeyLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RevokeKeyParams>(apiClient) {}
+
+QString RevokeKeyLoader::path(const RevokeKeyParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Auth/Keys/") + Support::toString< QString>(params.key()) ;
+}
+
+QUrlQuery RevokeKeyLoader::query(const RevokeKeyParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray RevokeKeyLoader::body(const RevokeKeyParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RevokeKeyLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/branding.cpp

@@ -65,7 +65,7 @@ QNetworkAccessManager::Operation GetBrandingOptionsLoader::operation() const {
 }
 
 GetBrandingCssLoader::GetBrandingCssLoader(ApiClient *apiClient)
-	: Jellyfin::Support::HttpLoader<QString, GetBrandingCssParams>(apiClient) {}
+	: Jellyfin::Support::HttpLoader<void, GetBrandingCssParams>(apiClient) {}
 
 QString GetBrandingCssLoader::path(const GetBrandingCssParams &params) const {
 	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@@ -94,7 +94,7 @@ QNetworkAccessManager::Operation GetBrandingCssLoader::operation() const {
 }
 
 GetBrandingCss_2Loader::GetBrandingCss_2Loader(ApiClient *apiClient)
-	: Jellyfin::Support::HttpLoader<QString, GetBrandingCss_2Params>(apiClient) {}
+	: Jellyfin::Support::HttpLoader<void, GetBrandingCss_2Params>(apiClient) {}
 
 QString GetBrandingCss_2Loader::path(const GetBrandingCss_2Params &params) const {
 	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

core/src/loader/http/collection.cpp

@@ -76,6 +76,66 @@ QNetworkAccessManager::Operation CreateCollectionLoader::operation() const {
 
 }
 
+AddToCollectionLoader::AddToCollectionLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, AddToCollectionParams>(apiClient) {}
+
+QString AddToCollectionLoader::path(const AddToCollectionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Collections/") + Support::toString< QString>(params.collectionId()) + QStringLiteral("/Items");
+}
+
+QUrlQuery AddToCollectionLoader::query(const AddToCollectionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray AddToCollectionLoader::body(const AddToCollectionParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation AddToCollectionLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+RemoveFromCollectionLoader::RemoveFromCollectionLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RemoveFromCollectionParams>(apiClient) {}
+
+QString RemoveFromCollectionLoader::path(const RemoveFromCollectionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Collections/") + Support::toString< QString>(params.collectionId()) + QStringLiteral("/Items");
+}
+
+QUrlQuery RemoveFromCollectionLoader::query(const RemoveFromCollectionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray RemoveFromCollectionLoader::body(const RemoveFromCollectionParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RemoveFromCollectionLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/configuration.cpp

@@ -64,6 +64,35 @@ QNetworkAccessManager::Operation GetConfigurationLoader::operation() const {
 
 }
 
+UpdateConfigurationLoader::UpdateConfigurationLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateConfigurationParams>(apiClient) {}
+
+QString UpdateConfigurationLoader::path(const UpdateConfigurationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/System/Configuration");
+}
+
+QUrlQuery UpdateConfigurationLoader::query(const UpdateConfigurationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateConfigurationLoader::body(const UpdateConfigurationParams &params) const {
+	return Support::toString<QSharedPointer<ServerConfiguration>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateConfigurationLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetNamedConfigurationLoader::GetNamedConfigurationLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QString, GetNamedConfigurationParams>(apiClient) {}
 
@@ -93,6 +122,35 @@ QNetworkAccessManager::Operation GetNamedConfigurationLoader::operation() const
 
 }
 
+UpdateNamedConfigurationLoader::UpdateNamedConfigurationLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateNamedConfigurationParams>(apiClient) {}
+
+QString UpdateNamedConfigurationLoader::path(const UpdateNamedConfigurationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/System/Configuration/") + Support::toString< QString>(params.key()) ;
+}
+
+QUrlQuery UpdateNamedConfigurationLoader::query(const UpdateNamedConfigurationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateNamedConfigurationLoader::body(const UpdateNamedConfigurationParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation UpdateNamedConfigurationLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetDefaultMetadataOptionsLoader::GetDefaultMetadataOptionsLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<MetadataOptions, GetDefaultMetadataOptionsParams>(apiClient) {}
 
@@ -122,6 +180,35 @@ QNetworkAccessManager::Operation GetDefaultMetadataOptionsLoader::operation() co
 
 }
 
+UpdateMediaEncoderPathLoader::UpdateMediaEncoderPathLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateMediaEncoderPathParams>(apiClient) {}
+
+QString UpdateMediaEncoderPathLoader::path(const UpdateMediaEncoderPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/System/MediaEncoder/Path");
+}
+
+QUrlQuery UpdateMediaEncoderPathLoader::query(const UpdateMediaEncoderPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateMediaEncoderPathLoader::body(const UpdateMediaEncoderPathParams &params) const {
+	return Support::toString<QSharedPointer<MediaEncoderPathDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateMediaEncoderPathLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/devices.cpp

@@ -70,6 +70,36 @@ QNetworkAccessManager::Operation GetDevicesLoader::operation() const {
 
 }
 
+DeleteDeviceLoader::DeleteDeviceLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteDeviceParams>(apiClient) {}
+
+QString DeleteDeviceLoader::path(const DeleteDeviceParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Devices");
+}
+
+QUrlQuery DeleteDeviceLoader::query(const DeleteDeviceParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DeleteDeviceLoader::body(const DeleteDeviceParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteDeviceLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetDeviceInfoLoader::GetDeviceInfoLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<DeviceInfo, GetDeviceInfoParams>(apiClient) {}
 
@@ -130,6 +160,36 @@ QNetworkAccessManager::Operation GetDeviceOptionsLoader::operation() const {
 
 }
 
+UpdateDeviceOptionsLoader::UpdateDeviceOptionsLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateDeviceOptionsParams>(apiClient) {}
+
+QString UpdateDeviceOptionsLoader::path(const UpdateDeviceOptionsParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Devices/Options");
+}
+
+QUrlQuery UpdateDeviceOptionsLoader::query(const UpdateDeviceOptionsParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateDeviceOptionsLoader::body(const UpdateDeviceOptionsParams &params) const {
+	return Support::toString<QSharedPointer<DeviceOptions>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateDeviceOptionsLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/displaypreferences.cpp

@@ -66,6 +66,37 @@ QNetworkAccessManager::Operation GetDisplayPreferencesLoader::operation() const
 
 }
 
+UpdateDisplayPreferencesLoader::UpdateDisplayPreferencesLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateDisplayPreferencesParams>(apiClient) {}
+
+QString UpdateDisplayPreferencesLoader::path(const UpdateDisplayPreferencesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/DisplayPreferences/") + Support::toString< QString>(params.displayPreferencesId()) ;
+}
+
+QUrlQuery UpdateDisplayPreferencesLoader::query(const UpdateDisplayPreferencesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("userId", Support::toString<QString>(params.userId()));
+	result.addQueryItem("client", Support::toString<QString>(params.client()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateDisplayPreferencesLoader::body(const UpdateDisplayPreferencesParams &params) const {
+	return Support::toString<QSharedPointer<DisplayPreferencesDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateDisplayPreferencesLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/dlna.cpp

@@ -64,6 +64,35 @@ QNetworkAccessManager::Operation GetProfileInfosLoader::operation() const {
 
 }
 
+CreateProfileLoader::CreateProfileLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CreateProfileParams>(apiClient) {}
+
+QString CreateProfileLoader::path(const CreateProfileParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Dlna/Profiles");
+}
+
+QUrlQuery CreateProfileLoader::query(const CreateProfileParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CreateProfileLoader::body(const CreateProfileParams &params) const {
+	return Support::toString<QSharedPointer<DeviceProfile>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation CreateProfileLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetProfileLoader::GetProfileLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<DeviceProfile, GetProfileParams>(apiClient) {}
 
@@ -93,6 +122,64 @@ QNetworkAccessManager::Operation GetProfileLoader::operation() const {
 
 }
 
+DeleteProfileLoader::DeleteProfileLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteProfileParams>(apiClient) {}
+
+QString DeleteProfileLoader::path(const DeleteProfileParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Dlna/Profiles/") + Support::toString< QString>(params.profileId()) ;
+}
+
+QUrlQuery DeleteProfileLoader::query(const DeleteProfileParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DeleteProfileLoader::body(const DeleteProfileParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteProfileLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+UpdateProfileLoader::UpdateProfileLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateProfileParams>(apiClient) {}
+
+QString UpdateProfileLoader::path(const UpdateProfileParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Dlna/Profiles/") + Support::toString< QString>(params.profileId()) ;
+}
+
+QUrlQuery UpdateProfileLoader::query(const UpdateProfileParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateProfileLoader::body(const UpdateProfileParams &params) const {
+	return Support::toString<QSharedPointer<DeviceProfile>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateProfileLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetDefaultProfileLoader::GetDefaultProfileLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<DeviceProfile, GetDefaultProfileParams>(apiClient) {}
 

core/src/loader/http/environment.cpp

@@ -188,6 +188,35 @@ QNetworkAccessManager::Operation GetParentPathLoader::operation() const {
 
 }
 
+ValidatePathLoader::ValidatePathLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ValidatePathParams>(apiClient) {}
+
+QString ValidatePathLoader::path(const ValidatePathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Environment/ValidatePath");
+}
+
+QUrlQuery ValidatePathLoader::query(const ValidatePathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray ValidatePathLoader::body(const ValidatePathParams &params) const {
+	return Support::toString<QSharedPointer<ValidatePathDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation ValidatePathLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/hlssegment.cpp

@@ -35,6 +35,41 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+StopEncodingProcessLoader::StopEncodingProcessLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, StopEncodingProcessParams>(apiClient) {}
+
+QString StopEncodingProcessLoader::path(const StopEncodingProcessParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Videos/ActiveEncodings");
+}
+
+QUrlQuery StopEncodingProcessLoader::query(const StopEncodingProcessParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.deviceIdNull()) {
+		result.addQueryItem("deviceId", Support::toString<QString>(params.deviceId()));
+	}
+	if (!params.playSessionIdNull()) {
+		result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
+	}
+	
+	return result;
+}
+
+QByteArray StopEncodingProcessLoader::body(const StopEncodingProcessParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation StopEncodingProcessLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/image.cpp

@@ -64,6 +64,279 @@ QNetworkAccessManager::Operation GetItemImageInfosLoader::operation() const {
 
 }
 
+DeleteItemImageLoader::DeleteItemImageLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteItemImageParams>(apiClient) {}
+
+QString DeleteItemImageLoader::path(const DeleteItemImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
+}
+
+QUrlQuery DeleteItemImageLoader::query(const DeleteItemImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.imageIndexNull()) {
+		result.addQueryItem("imageIndex", Support::toString<std::optional<qint32>>(params.imageIndex()));
+	}
+	
+	return result;
+}
+
+QByteArray DeleteItemImageLoader::body(const DeleteItemImageParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteItemImageLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+SetItemImageLoader::SetItemImageLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, SetItemImageParams>(apiClient) {}
+
+QString SetItemImageLoader::path(const SetItemImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
+}
+
+QUrlQuery SetItemImageLoader::query(const SetItemImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray SetItemImageLoader::body(const SetItemImageParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation SetItemImageLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+DeleteItemImageByIndexLoader::DeleteItemImageByIndexLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteItemImageByIndexParams>(apiClient) {}
+
+QString DeleteItemImageByIndexLoader::path(const DeleteItemImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.imageIndex()) ;
+}
+
+QUrlQuery DeleteItemImageByIndexLoader::query(const DeleteItemImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DeleteItemImageByIndexLoader::body(const DeleteItemImageByIndexParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteItemImageByIndexLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+SetItemImageByIndexLoader::SetItemImageByIndexLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, SetItemImageByIndexParams>(apiClient) {}
+
+QString SetItemImageByIndexLoader::path(const SetItemImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.imageIndex()) ;
+}
+
+QUrlQuery SetItemImageByIndexLoader::query(const SetItemImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray SetItemImageByIndexLoader::body(const SetItemImageByIndexParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation SetItemImageByIndexLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+UpdateItemImageIndexLoader::UpdateItemImageIndexLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateItemImageIndexParams>(apiClient) {}
+
+QString UpdateItemImageIndexLoader::path(const UpdateItemImageIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.imageIndex()) + QStringLiteral("/Index");
+}
+
+QUrlQuery UpdateItemImageIndexLoader::query(const UpdateItemImageIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.newIndexNull()) {
+		result.addQueryItem("newIndex", Support::toString<std::optional<qint32>>(params.newIndex()));
+	}
+	
+	return result;
+}
+
+QByteArray UpdateItemImageIndexLoader::body(const UpdateItemImageIndexParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation UpdateItemImageIndexLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+PostUserImageLoader::PostUserImageLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostUserImageParams>(apiClient) {}
+
+QString PostUserImageLoader::path(const PostUserImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
+}
+
+QUrlQuery PostUserImageLoader::query(const PostUserImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.indexNull()) {
+		result.addQueryItem("index", Support::toString<std::optional<qint32>>(params.index()));
+	}
+	
+	return result;
+}
+
+QByteArray PostUserImageLoader::body(const PostUserImageParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostUserImageLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+DeleteUserImageLoader::DeleteUserImageLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteUserImageParams>(apiClient) {}
+
+QString DeleteUserImageLoader::path(const DeleteUserImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
+}
+
+QUrlQuery DeleteUserImageLoader::query(const DeleteUserImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.indexNull()) {
+		result.addQueryItem("index", Support::toString<std::optional<qint32>>(params.index()));
+	}
+	
+	return result;
+}
+
+QByteArray DeleteUserImageLoader::body(const DeleteUserImageParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteUserImageLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+PostUserImageByIndexLoader::PostUserImageByIndexLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostUserImageByIndexParams>(apiClient) {}
+
+QString PostUserImageByIndexLoader::path(const PostUserImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.index()) ;
+}
+
+QUrlQuery PostUserImageByIndexLoader::query(const PostUserImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray PostUserImageByIndexLoader::body(const PostUserImageByIndexParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostUserImageByIndexLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+DeleteUserImageByIndexLoader::DeleteUserImageByIndexLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteUserImageByIndexParams>(apiClient) {}
+
+QString DeleteUserImageByIndexLoader::path(const DeleteUserImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.index()) ;
+}
+
+QUrlQuery DeleteUserImageByIndexLoader::query(const DeleteUserImageByIndexParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DeleteUserImageByIndexLoader::body(const DeleteUserImageByIndexParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteUserImageByIndexLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/itemlookup.cpp

@@ -64,6 +64,38 @@ QNetworkAccessManager::Operation GetExternalIdInfosLoader::operation() const {
 
 }
 
+ApplySearchCriteriaLoader::ApplySearchCriteriaLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ApplySearchCriteriaParams>(apiClient) {}
+
+QString ApplySearchCriteriaLoader::path(const ApplySearchCriteriaParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/RemoteSearch/Apply/") + Support::toString< QString>(params.itemId()) ;
+}
+
+QUrlQuery ApplySearchCriteriaLoader::query(const ApplySearchCriteriaParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.replaceAllImagesNull()) {
+		result.addQueryItem("replaceAllImages", Support::toString<std::optional<bool>>(params.replaceAllImages()));
+	}
+	
+	return result;
+}
+
+QByteArray ApplySearchCriteriaLoader::body(const ApplySearchCriteriaParams &params) const {
+	return Support::toString<QSharedPointer<RemoteSearchResult>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation ApplySearchCriteriaLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetBookRemoteSearchResultsLoader::GetBookRemoteSearchResultsLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetBookRemoteSearchResultsParams>(apiClient) {}
 

core/src/loader/http/itemrefresh.cpp

@@ -35,6 +35,47 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+PostLoader::PostLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostParams>(apiClient) {}
+
+QString PostLoader::path(const PostParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Refresh");
+}
+
+QUrlQuery PostLoader::query(const PostParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.metadataRefreshModeNull()) {
+		result.addQueryItem("metadataRefreshMode", Support::toString<MetadataRefreshMode>(params.metadataRefreshMode()));
+	}
+	if (!params.imageRefreshModeNull()) {
+		result.addQueryItem("imageRefreshMode", Support::toString<MetadataRefreshMode>(params.imageRefreshMode()));
+	}
+	if (!params.replaceAllMetadataNull()) {
+		result.addQueryItem("replaceAllMetadata", Support::toString<std::optional<bool>>(params.replaceAllMetadata()));
+	}
+	if (!params.replaceAllImagesNull()) {
+		result.addQueryItem("replaceAllImages", Support::toString<std::optional<bool>>(params.replaceAllImages()));
+	}
+	
+	return result;
+}
+
+QByteArray PostLoader::body(const PostParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/itemupdate.cpp

@@ -35,6 +35,67 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+UpdateItemLoader::UpdateItemLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateItemParams>(apiClient) {}
+
+QString UpdateItemLoader::path(const UpdateItemParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) ;
+}
+
+QUrlQuery UpdateItemLoader::query(const UpdateItemParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateItemLoader::body(const UpdateItemParams &params) const {
+	return Support::toString<QSharedPointer<BaseItemDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateItemLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+UpdateItemContentTypeLoader::UpdateItemContentTypeLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateItemContentTypeParams>(apiClient) {}
+
+QString UpdateItemContentTypeLoader::path(const UpdateItemContentTypeParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/ContentType");
+}
+
+QUrlQuery UpdateItemContentTypeLoader::query(const UpdateItemContentTypeParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.contentTypeNull()) {
+		result.addQueryItem("contentType", Support::toString<QString>(params.contentType()));
+	}
+	
+	return result;
+}
+
+QByteArray UpdateItemContentTypeLoader::body(const UpdateItemContentTypeParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation UpdateItemContentTypeLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetMetadataEditorInfoLoader::GetMetadataEditorInfoLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<MetadataEditorInfo, GetMetadataEditorInfoParams>(apiClient) {}
 

core/src/loader/http/library.cpp

@@ -35,6 +35,67 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+DeleteItemsLoader::DeleteItemsLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteItemsParams>(apiClient) {}
+
+QString DeleteItemsLoader::path(const DeleteItemsParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items");
+}
+
+QUrlQuery DeleteItemsLoader::query(const DeleteItemsParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.idsNull()) {
+		result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
+	}
+	
+	return result;
+}
+
+QByteArray DeleteItemsLoader::body(const DeleteItemsParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteItemsLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+DeleteItemLoader::DeleteItemLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteItemParams>(apiClient) {}
+
+QString DeleteItemLoader::path(const DeleteItemParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) ;
+}
+
+QUrlQuery DeleteItemLoader::query(const DeleteItemParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DeleteItemLoader::body(const DeleteItemParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteItemLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetSimilarAlbumsLoader::GetSimilarAlbumsLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarAlbumsParams>(apiClient) {}
 
@@ -394,6 +455,35 @@ QNetworkAccessManager::Operation GetLibraryOptionsInfoLoader::operation() const
 
 }
 
+PostUpdatedMediaLoader::PostUpdatedMediaLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostUpdatedMediaParams>(apiClient) {}
+
+QString PostUpdatedMediaLoader::path(const PostUpdatedMediaParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/Media/Updated");
+}
+
+QUrlQuery PostUpdatedMediaLoader::query(const PostUpdatedMediaParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray PostUpdatedMediaLoader::body(const PostUpdatedMediaParams &params) const {
+	return Support::toString<QList<MediaUpdateInfoDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation PostUpdatedMediaLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetMediaFoldersLoader::GetMediaFoldersLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetMediaFoldersParams>(apiClient) {}
 
@@ -426,6 +516,76 @@ QNetworkAccessManager::Operation GetMediaFoldersLoader::operation() const {
 
 }
 
+PostAddedMoviesLoader::PostAddedMoviesLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostAddedMoviesParams>(apiClient) {}
+
+QString PostAddedMoviesLoader::path(const PostAddedMoviesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/Movies/Added");
+}
+
+QUrlQuery PostAddedMoviesLoader::query(const PostAddedMoviesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.tmdbIdNull()) {
+		result.addQueryItem("tmdbId", Support::toString<QString>(params.tmdbId()));
+	}
+	if (!params.imdbIdNull()) {
+		result.addQueryItem("imdbId", Support::toString<QString>(params.imdbId()));
+	}
+	
+	return result;
+}
+
+QByteArray PostAddedMoviesLoader::body(const PostAddedMoviesParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostAddedMoviesLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+PostUpdatedMoviesLoader::PostUpdatedMoviesLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostUpdatedMoviesParams>(apiClient) {}
+
+QString PostUpdatedMoviesLoader::path(const PostUpdatedMoviesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/Movies/Updated");
+}
+
+QUrlQuery PostUpdatedMoviesLoader::query(const PostUpdatedMoviesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.tmdbIdNull()) {
+		result.addQueryItem("tmdbId", Support::toString<QString>(params.tmdbId()));
+	}
+	if (!params.imdbIdNull()) {
+		result.addQueryItem("imdbId", Support::toString<QString>(params.imdbId()));
+	}
+	
+	return result;
+}
+
+QByteArray PostUpdatedMoviesLoader::body(const PostUpdatedMoviesParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostUpdatedMoviesLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetPhysicalPathsLoader::GetPhysicalPathsLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QStringList, GetPhysicalPathsParams>(apiClient) {}
 
@@ -455,6 +615,99 @@ QNetworkAccessManager::Operation GetPhysicalPathsLoader::operation() const {
 
 }
 
+RefreshLibraryLoader::RefreshLibraryLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RefreshLibraryParams>(apiClient) {}
+
+QString RefreshLibraryLoader::path(const RefreshLibraryParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/Refresh");
+}
+
+QUrlQuery RefreshLibraryLoader::query(const RefreshLibraryParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray RefreshLibraryLoader::body(const RefreshLibraryParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RefreshLibraryLoader::operation() const {
+	// HTTP method Get
+	return QNetworkAccessManager::GetOperation;
+
+}
+
+PostAddedSeriesLoader::PostAddedSeriesLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostAddedSeriesParams>(apiClient) {}
+
+QString PostAddedSeriesLoader::path(const PostAddedSeriesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/Series/Added");
+}
+
+QUrlQuery PostAddedSeriesLoader::query(const PostAddedSeriesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.tvdbIdNull()) {
+		result.addQueryItem("tvdbId", Support::toString<QString>(params.tvdbId()));
+	}
+	
+	return result;
+}
+
+QByteArray PostAddedSeriesLoader::body(const PostAddedSeriesParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostAddedSeriesLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+PostUpdatedSeriesLoader::PostUpdatedSeriesLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PostUpdatedSeriesParams>(apiClient) {}
+
+QString PostUpdatedSeriesLoader::path(const PostUpdatedSeriesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/Series/Updated");
+}
+
+QUrlQuery PostUpdatedSeriesLoader::query(const PostUpdatedSeriesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.tvdbIdNull()) {
+		result.addQueryItem("tvdbId", Support::toString<QString>(params.tvdbId()));
+	}
+	
+	return result;
+}
+
+QByteArray PostUpdatedSeriesLoader::body(const PostUpdatedSeriesParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PostUpdatedSeriesLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetSimilarMoviesLoader::GetSimilarMoviesLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarMoviesParams>(apiClient) {}
 

core/src/loader/http/librarystructure.cpp

@@ -64,6 +64,251 @@ QNetworkAccessManager::Operation GetVirtualFoldersLoader::operation() const {
 
 }
 
+AddVirtualFolderLoader::AddVirtualFolderLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, AddVirtualFolderParams>(apiClient) {}
+
+QString AddVirtualFolderLoader::path(const AddVirtualFolderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders");
+}
+
+QUrlQuery AddVirtualFolderLoader::query(const AddVirtualFolderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.nameNull()) {
+		result.addQueryItem("name", Support::toString<QString>(params.name()));
+	}
+	if (!params.collectionTypeNull()) {
+		result.addQueryItem("collectionType", Support::toString<QString>(params.collectionType()));
+	}
+	if (!params.pathsNull()) {
+		result.addQueryItem("paths", Support::toString<QStringList>(params.paths()));
+	}
+	if (!params.refreshLibraryNull()) {
+		result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
+	}
+	
+	return result;
+}
+
+QByteArray AddVirtualFolderLoader::body(const AddVirtualFolderParams &params) const {
+	return Support::toString<QSharedPointer<AddVirtualFolderDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation AddVirtualFolderLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+RemoveVirtualFolderLoader::RemoveVirtualFolderLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RemoveVirtualFolderParams>(apiClient) {}
+
+QString RemoveVirtualFolderLoader::path(const RemoveVirtualFolderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders");
+}
+
+QUrlQuery RemoveVirtualFolderLoader::query(const RemoveVirtualFolderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.nameNull()) {
+		result.addQueryItem("name", Support::toString<QString>(params.name()));
+	}
+	if (!params.refreshLibraryNull()) {
+		result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
+	}
+	
+	return result;
+}
+
+QByteArray RemoveVirtualFolderLoader::body(const RemoveVirtualFolderParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RemoveVirtualFolderLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+UpdateLibraryOptionsLoader::UpdateLibraryOptionsLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateLibraryOptionsParams>(apiClient) {}
+
+QString UpdateLibraryOptionsLoader::path(const UpdateLibraryOptionsParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders/LibraryOptions");
+}
+
+QUrlQuery UpdateLibraryOptionsLoader::query(const UpdateLibraryOptionsParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateLibraryOptionsLoader::body(const UpdateLibraryOptionsParams &params) const {
+	return Support::toString<QSharedPointer<UpdateLibraryOptionsDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateLibraryOptionsLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+RenameVirtualFolderLoader::RenameVirtualFolderLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RenameVirtualFolderParams>(apiClient) {}
+
+QString RenameVirtualFolderLoader::path(const RenameVirtualFolderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders/Name");
+}
+
+QUrlQuery RenameVirtualFolderLoader::query(const RenameVirtualFolderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.nameNull()) {
+		result.addQueryItem("name", Support::toString<QString>(params.name()));
+	}
+	if (!params.newNameNull()) {
+		result.addQueryItem("newName", Support::toString<QString>(params.newName()));
+	}
+	if (!params.refreshLibraryNull()) {
+		result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
+	}
+	
+	return result;
+}
+
+QByteArray RenameVirtualFolderLoader::body(const RenameVirtualFolderParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RenameVirtualFolderLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+AddMediaPathLoader::AddMediaPathLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, AddMediaPathParams>(apiClient) {}
+
+QString AddMediaPathLoader::path(const AddMediaPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders/Paths");
+}
+
+QUrlQuery AddMediaPathLoader::query(const AddMediaPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.refreshLibraryNull()) {
+		result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
+	}
+	
+	return result;
+}
+
+QByteArray AddMediaPathLoader::body(const AddMediaPathParams &params) const {
+	return Support::toString<QSharedPointer<MediaPathDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation AddMediaPathLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+RemoveMediaPathLoader::RemoveMediaPathLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RemoveMediaPathParams>(apiClient) {}
+
+QString RemoveMediaPathLoader::path(const RemoveMediaPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders/Paths");
+}
+
+QUrlQuery RemoveMediaPathLoader::query(const RemoveMediaPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.nameNull()) {
+		result.addQueryItem("name", Support::toString<QString>(params.name()));
+	}
+	if (!params.pathNull()) {
+		result.addQueryItem("path", Support::toString<QString>(params.path()));
+	}
+	if (!params.refreshLibraryNull()) {
+		result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
+	}
+	
+	return result;
+}
+
+QByteArray RemoveMediaPathLoader::body(const RemoveMediaPathParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RemoveMediaPathLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+UpdateMediaPathLoader::UpdateMediaPathLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateMediaPathParams>(apiClient) {}
+
+QString UpdateMediaPathLoader::path(const UpdateMediaPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Library/VirtualFolders/Paths/Update");
+}
+
+QUrlQuery UpdateMediaPathLoader::query(const UpdateMediaPathParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.nameNull()) {
+		result.addQueryItem("name", Support::toString<QString>(params.name()));
+	}
+	
+	return result;
+}
+
+QByteArray UpdateMediaPathLoader::body(const UpdateMediaPathParams &params) const {
+	return Support::toString<QSharedPointer<MediaPathInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateMediaPathLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/livetv.cpp

@@ -316,6 +316,38 @@ QNetworkAccessManager::Operation AddListingProviderLoader::operation() const {
 
 }
 
+DeleteListingProviderLoader::DeleteListingProviderLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteListingProviderParams>(apiClient) {}
+
+QString DeleteListingProviderLoader::path(const DeleteListingProviderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/ListingProviders");
+}
+
+QUrlQuery DeleteListingProviderLoader::query(const DeleteListingProviderParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.jellyfinIdNull()) {
+		result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
+	}
+	
+	return result;
+}
+
+QByteArray DeleteListingProviderLoader::body(const DeleteListingProviderParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteListingProviderLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetDefaultListingProviderLoader::GetDefaultListingProviderLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<ListingsProviderInfo, GetDefaultListingProviderParams>(apiClient) {}
 
@@ -781,6 +813,35 @@ QNetworkAccessManager::Operation GetRecordingLoader::operation() const {
 
 }
 
+DeleteRecordingLoader::DeleteRecordingLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteRecordingParams>(apiClient) {}
+
+QString DeleteRecordingLoader::path(const DeleteRecordingParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/Recordings/") + Support::toString< QString>(params.recordingId()) ;
+}
+
+QUrlQuery DeleteRecordingLoader::query(const DeleteRecordingParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DeleteRecordingLoader::body(const DeleteRecordingParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteRecordingLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetRecordingFoldersLoader::GetRecordingFoldersLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecordingFoldersParams>(apiClient) {}
 
@@ -951,6 +1012,35 @@ QNetworkAccessManager::Operation GetSeriesTimersLoader::operation() const {
 
 }
 
+CreateSeriesTimerLoader::CreateSeriesTimerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CreateSeriesTimerParams>(apiClient) {}
+
+QString CreateSeriesTimerLoader::path(const CreateSeriesTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/SeriesTimers");
+}
+
+QUrlQuery CreateSeriesTimerLoader::query(const CreateSeriesTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CreateSeriesTimerLoader::body(const CreateSeriesTimerParams &params) const {
+	return Support::toString<QSharedPointer<SeriesTimerInfoDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation CreateSeriesTimerLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetSeriesTimerLoader::GetSeriesTimerLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetSeriesTimerParams>(apiClient) {}
 
@@ -980,6 +1070,64 @@ QNetworkAccessManager::Operation GetSeriesTimerLoader::operation() const {
 
 }
 
+CancelSeriesTimerLoader::CancelSeriesTimerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CancelSeriesTimerParams>(apiClient) {}
+
+QString CancelSeriesTimerLoader::path(const CancelSeriesTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/SeriesTimers/") + Support::toString< QString>(params.timerId()) ;
+}
+
+QUrlQuery CancelSeriesTimerLoader::query(const CancelSeriesTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CancelSeriesTimerLoader::body(const CancelSeriesTimerParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation CancelSeriesTimerLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+UpdateSeriesTimerLoader::UpdateSeriesTimerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateSeriesTimerParams>(apiClient) {}
+
+QString UpdateSeriesTimerLoader::path(const UpdateSeriesTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/SeriesTimers/") + Support::toString< QString>(params.timerId()) ;
+}
+
+QUrlQuery UpdateSeriesTimerLoader::query(const UpdateSeriesTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateSeriesTimerLoader::body(const UpdateSeriesTimerParams &params) const {
+	return Support::toString<QSharedPointer<SeriesTimerInfoDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateSeriesTimerLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetTimersLoader::GetTimersLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<TimerInfoDtoQueryResult, GetTimersParams>(apiClient) {}
 
@@ -1021,6 +1169,35 @@ QNetworkAccessManager::Operation GetTimersLoader::operation() const {
 
 }
 
+CreateTimerLoader::CreateTimerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CreateTimerParams>(apiClient) {}
+
+QString CreateTimerLoader::path(const CreateTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/Timers");
+}
+
+QUrlQuery CreateTimerLoader::query(const CreateTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CreateTimerLoader::body(const CreateTimerParams &params) const {
+	return Support::toString<QSharedPointer<TimerInfoDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation CreateTimerLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetTimerLoader::GetTimerLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<TimerInfoDto, GetTimerParams>(apiClient) {}
 
@@ -1050,6 +1227,64 @@ QNetworkAccessManager::Operation GetTimerLoader::operation() const {
 
 }
 
+CancelTimerLoader::CancelTimerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CancelTimerParams>(apiClient) {}
+
+QString CancelTimerLoader::path(const CancelTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/Timers/") + Support::toString< QString>(params.timerId()) ;
+}
+
+QUrlQuery CancelTimerLoader::query(const CancelTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CancelTimerLoader::body(const CancelTimerParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation CancelTimerLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+UpdateTimerLoader::UpdateTimerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateTimerParams>(apiClient) {}
+
+QString UpdateTimerLoader::path(const UpdateTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/Timers/") + Support::toString< QString>(params.timerId()) ;
+}
+
+QUrlQuery UpdateTimerLoader::query(const UpdateTimerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateTimerLoader::body(const UpdateTimerParams &params) const {
+	return Support::toString<QSharedPointer<TimerInfoDto>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateTimerLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetDefaultTimerLoader::GetDefaultTimerLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetDefaultTimerParams>(apiClient) {}
 
@@ -1111,6 +1346,38 @@ QNetworkAccessManager::Operation AddTunerHostLoader::operation() const {
 
 }
 
+DeleteTunerHostLoader::DeleteTunerHostLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DeleteTunerHostParams>(apiClient) {}
+
+QString DeleteTunerHostLoader::path(const DeleteTunerHostParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/TunerHosts");
+}
+
+QUrlQuery DeleteTunerHostLoader::query(const DeleteTunerHostParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.jellyfinIdNull()) {
+		result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
+	}
+	
+	return result;
+}
+
+QByteArray DeleteTunerHostLoader::body(const DeleteTunerHostParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DeleteTunerHostLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetTunerHostTypesLoader::GetTunerHostTypesLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetTunerHostTypesParams>(apiClient) {}
 
@@ -1140,6 +1407,35 @@ QNetworkAccessManager::Operation GetTunerHostTypesLoader::operation() const {
 
 }
 
+ResetTunerLoader::ResetTunerLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ResetTunerParams>(apiClient) {}
+
+QString ResetTunerLoader::path(const ResetTunerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveTv/Tuners/") + Support::toString< QString>(params.tunerId()) + QStringLiteral("/Reset");
+}
+
+QUrlQuery ResetTunerLoader::query(const ResetTunerParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray ResetTunerLoader::body(const ResetTunerParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation ResetTunerLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 DiscoverTunersLoader::DiscoverTunersLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QList<TunerHostInfo>, DiscoverTunersParams>(apiClient) {}
 

core/src/loader/http/mediainfo.cpp

@@ -136,6 +136,36 @@ QNetworkAccessManager::Operation GetPostedPlaybackInfoLoader::operation() const
 
 }
 
+CloseLiveStreamLoader::CloseLiveStreamLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CloseLiveStreamParams>(apiClient) {}
+
+QString CloseLiveStreamLoader::path(const CloseLiveStreamParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/LiveStreams/Close");
+}
+
+QUrlQuery CloseLiveStreamLoader::query(const CloseLiveStreamParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CloseLiveStreamLoader::body(const CloseLiveStreamParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation CloseLiveStreamLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 OpenLiveStreamLoader::OpenLiveStreamLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<LiveStreamResponse, OpenLiveStreamParams>(apiClient) {}
 

core/src/loader/http/notifications.cpp

@@ -64,6 +64,35 @@ QNetworkAccessManager::Operation GetNotificationsLoader::operation() const {
 
 }
 
+SetReadLoader::SetReadLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, SetReadParams>(apiClient) {}
+
+QString SetReadLoader::path(const SetReadParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Notifications/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Read");
+}
+
+QUrlQuery SetReadLoader::query(const SetReadParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray SetReadLoader::body(const SetReadParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation SetReadLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetNotificationsSummaryLoader::GetNotificationsSummaryLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<NotificationsSummaryDto, GetNotificationsSummaryParams>(apiClient) {}
 
@@ -93,6 +122,76 @@ QNetworkAccessManager::Operation GetNotificationsSummaryLoader::operation() cons
 
 }
 
+SetUnreadLoader::SetUnreadLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, SetUnreadParams>(apiClient) {}
+
+QString SetUnreadLoader::path(const SetUnreadParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Notifications/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Unread");
+}
+
+QUrlQuery SetUnreadLoader::query(const SetUnreadParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray SetUnreadLoader::body(const SetUnreadParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation SetUnreadLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+CreateAdminNotificationLoader::CreateAdminNotificationLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CreateAdminNotificationParams>(apiClient) {}
+
+QString CreateAdminNotificationLoader::path(const CreateAdminNotificationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Notifications/Admin");
+}
+
+QUrlQuery CreateAdminNotificationLoader::query(const CreateAdminNotificationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.urlNull()) {
+		result.addQueryItem("url", Support::toString<QString>(params.url()));
+	}
+	if (!params.levelNull()) {
+		result.addQueryItem("level", Support::toString<NotificationLevel>(params.level()));
+	}
+	if (!params.nameNull()) {
+		result.addQueryItem("name", Support::toString<QString>(params.name()));
+	}
+	if (!params.descriptionNull()) {
+		result.addQueryItem("description", Support::toString<QString>(params.description()));
+	}
+	
+	return result;
+}
+
+QByteArray CreateAdminNotificationLoader::body(const CreateAdminNotificationParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation CreateAdminNotificationLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetNotificationServicesLoader::GetNotificationServicesLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetNotificationServicesParams>(apiClient) {}
 

core/src/loader/http/package.cpp

@@ -96,6 +96,73 @@ QNetworkAccessManager::Operation GetPackageInfoLoader::operation() const {
 
 }
 
+InstallPackageLoader::InstallPackageLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, InstallPackageParams>(apiClient) {}
+
+QString InstallPackageLoader::path(const InstallPackageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Packages/Installed/") + Support::toString< QString>(params.name()) ;
+}
+
+QUrlQuery InstallPackageLoader::query(const InstallPackageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.assemblyGuidNull()) {
+		result.addQueryItem("assemblyGuid", Support::toString<QString>(params.assemblyGuid()));
+	}
+	if (!params.versionNull()) {
+		result.addQueryItem("version", Support::toString<QString>(params.version()));
+	}
+	if (!params.repositoryUrlNull()) {
+		result.addQueryItem("repositoryUrl", Support::toString<QString>(params.repositoryUrl()));
+	}
+	
+	return result;
+}
+
+QByteArray InstallPackageLoader::body(const InstallPackageParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation InstallPackageLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+CancelPackageInstallationLoader::CancelPackageInstallationLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, CancelPackageInstallationParams>(apiClient) {}
+
+QString CancelPackageInstallationLoader::path(const CancelPackageInstallationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Packages/Installing/") + Support::toString< QString>(params.packageId()) ;
+}
+
+QUrlQuery CancelPackageInstallationLoader::query(const CancelPackageInstallationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray CancelPackageInstallationLoader::body(const CancelPackageInstallationParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation CancelPackageInstallationLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetRepositoriesLoader::GetRepositoriesLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QList<RepositoryInfo>, GetRepositoriesParams>(apiClient) {}
 
@@ -125,6 +192,35 @@ QNetworkAccessManager::Operation GetRepositoriesLoader::operation() const {
 
 }
 
+SetRepositoriesLoader::SetRepositoriesLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, SetRepositoriesParams>(apiClient) {}
+
+QString SetRepositoriesLoader::path(const SetRepositoriesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Repositories");
+}
+
+QUrlQuery SetRepositoriesLoader::query(const SetRepositoriesParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray SetRepositoriesLoader::body(const SetRepositoriesParams &params) const {
+	return Support::toString<QList<RepositoryInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation SetRepositoriesLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/playlists.cpp

@@ -76,6 +76,73 @@ QNetworkAccessManager::Operation CreatePlaylistLoader::operation() const {
 
 }
 
+AddToPlaylistLoader::AddToPlaylistLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, AddToPlaylistParams>(apiClient) {}
+
+QString AddToPlaylistLoader::path(const AddToPlaylistParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Playlists/") + Support::toString< QString>(params.playlistId()) + QStringLiteral("/Items");
+}
+
+QUrlQuery AddToPlaylistLoader::query(const AddToPlaylistParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.idsNull()) {
+		result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
+	}
+	if (!params.userIdNull()) {
+		result.addQueryItem("userId", Support::toString<QString>(params.userId()));
+	}
+	
+	return result;
+}
+
+QByteArray AddToPlaylistLoader::body(const AddToPlaylistParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation AddToPlaylistLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+RemoveFromPlaylistLoader::RemoveFromPlaylistLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, RemoveFromPlaylistParams>(apiClient) {}
+
+QString RemoveFromPlaylistLoader::path(const RemoveFromPlaylistParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Playlists/") + Support::toString< QString>(params.playlistId()) + QStringLiteral("/Items");
+}
+
+QUrlQuery RemoveFromPlaylistLoader::query(const RemoveFromPlaylistParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.entryIdsNull()) {
+		result.addQueryItem("entryIds", Support::toString<QStringList>(params.entryIds()));
+	}
+	
+	return result;
+}
+
+QByteArray RemoveFromPlaylistLoader::body(const RemoveFromPlaylistParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation RemoveFromPlaylistLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 GetPlaylistItemsLoader::GetPlaylistItemsLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetPlaylistItemsParams>(apiClient) {}
 
@@ -127,6 +194,35 @@ QNetworkAccessManager::Operation GetPlaylistItemsLoader::operation() const {
 
 }
 
+MoveItemLoader::MoveItemLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, MoveItemParams>(apiClient) {}
+
+QString MoveItemLoader::path(const MoveItemParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Playlists/") + Support::toString< QString>(params.playlistId()) + QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Move/") + Support::toString< qint32>(params.newIndex()) ;
+}
+
+QUrlQuery MoveItemLoader::query(const MoveItemParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray MoveItemLoader::body(const MoveItemParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation MoveItemLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/playstate.cpp

@@ -35,6 +35,125 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+ReportPlaybackStartLoader::ReportPlaybackStartLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ReportPlaybackStartParams>(apiClient) {}
+
+QString ReportPlaybackStartLoader::path(const ReportPlaybackStartParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Sessions/Playing");
+}
+
+QUrlQuery ReportPlaybackStartLoader::query(const ReportPlaybackStartParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray ReportPlaybackStartLoader::body(const ReportPlaybackStartParams &params) const {
+	return Support::toString<QSharedPointer<PlaybackStartInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation ReportPlaybackStartLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+PingPlaybackSessionLoader::PingPlaybackSessionLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, PingPlaybackSessionParams>(apiClient) {}
+
+QString PingPlaybackSessionLoader::path(const PingPlaybackSessionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Sessions/Playing/Ping");
+}
+
+QUrlQuery PingPlaybackSessionLoader::query(const PingPlaybackSessionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.playSessionIdNull()) {
+		result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
+	}
+	
+	return result;
+}
+
+QByteArray PingPlaybackSessionLoader::body(const PingPlaybackSessionParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation PingPlaybackSessionLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+ReportPlaybackProgressLoader::ReportPlaybackProgressLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ReportPlaybackProgressParams>(apiClient) {}
+
+QString ReportPlaybackProgressLoader::path(const ReportPlaybackProgressParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Sessions/Playing/Progress");
+}
+
+QUrlQuery ReportPlaybackProgressLoader::query(const ReportPlaybackProgressParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray ReportPlaybackProgressLoader::body(const ReportPlaybackProgressParams &params) const {
+	return Support::toString<QSharedPointer<PlaybackProgressInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation ReportPlaybackProgressLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+ReportPlaybackStoppedLoader::ReportPlaybackStoppedLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ReportPlaybackStoppedParams>(apiClient) {}
+
+QString ReportPlaybackStoppedLoader::path(const ReportPlaybackStoppedParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Sessions/Playing/Stopped");
+}
+
+QUrlQuery ReportPlaybackStoppedLoader::query(const ReportPlaybackStoppedParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray ReportPlaybackStoppedLoader::body(const ReportPlaybackStoppedParams &params) const {
+	return Support::toString<QSharedPointer<PlaybackStopInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation ReportPlaybackStoppedLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 MarkPlayedItemLoader::MarkPlayedItemLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<UserItemDataDto, MarkPlayedItemParams>(apiClient) {}
 
@@ -96,6 +215,162 @@ QNetworkAccessManager::Operation MarkUnplayedItemLoader::operation() const {
 
 }
 
+OnPlaybackStartLoader::OnPlaybackStartLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, OnPlaybackStartParams>(apiClient) {}
+
+QString OnPlaybackStartLoader::path(const OnPlaybackStartParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/PlayingItems/") + Support::toString< QString>(params.itemId()) ;
+}
+
+QUrlQuery OnPlaybackStartLoader::query(const OnPlaybackStartParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.mediaSourceIdNull()) {
+		result.addQueryItem("mediaSourceId", Support::toString<QString>(params.mediaSourceId()));
+	}
+	if (!params.audioStreamIndexNull()) {
+		result.addQueryItem("audioStreamIndex", Support::toString<std::optional<qint32>>(params.audioStreamIndex()));
+	}
+	if (!params.subtitleStreamIndexNull()) {
+		result.addQueryItem("subtitleStreamIndex", Support::toString<std::optional<qint32>>(params.subtitleStreamIndex()));
+	}
+	if (!params.playMethodNull()) {
+		result.addQueryItem("playMethod", Support::toString<PlayMethod>(params.playMethod()));
+	}
+	if (!params.liveStreamIdNull()) {
+		result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
+	}
+	if (!params.playSessionIdNull()) {
+		result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
+	}
+	if (!params.canSeekNull()) {
+		result.addQueryItem("canSeek", Support::toString<std::optional<bool>>(params.canSeek()));
+	}
+	
+	return result;
+}
+
+QByteArray OnPlaybackStartLoader::body(const OnPlaybackStartParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation OnPlaybackStartLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+OnPlaybackStoppedLoader::OnPlaybackStoppedLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, OnPlaybackStoppedParams>(apiClient) {}
+
+QString OnPlaybackStoppedLoader::path(const OnPlaybackStoppedParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/PlayingItems/") + Support::toString< QString>(params.itemId()) ;
+}
+
+QUrlQuery OnPlaybackStoppedLoader::query(const OnPlaybackStoppedParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.mediaSourceIdNull()) {
+		result.addQueryItem("mediaSourceId", Support::toString<QString>(params.mediaSourceId()));
+	}
+	if (!params.nextMediaTypeNull()) {
+		result.addQueryItem("nextMediaType", Support::toString<QString>(params.nextMediaType()));
+	}
+	if (!params.positionTicksNull()) {
+		result.addQueryItem("positionTicks", Support::toString<std::optional<qint64>>(params.positionTicks()));
+	}
+	if (!params.liveStreamIdNull()) {
+		result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
+	}
+	if (!params.playSessionIdNull()) {
+		result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
+	}
+	
+	return result;
+}
+
+QByteArray OnPlaybackStoppedLoader::body(const OnPlaybackStoppedParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation OnPlaybackStoppedLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+OnPlaybackProgressLoader::OnPlaybackProgressLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, OnPlaybackProgressParams>(apiClient) {}
+
+QString OnPlaybackProgressLoader::path(const OnPlaybackProgressParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/PlayingItems/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Progress");
+}
+
+QUrlQuery OnPlaybackProgressLoader::query(const OnPlaybackProgressParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.mediaSourceIdNull()) {
+		result.addQueryItem("mediaSourceId", Support::toString<QString>(params.mediaSourceId()));
+	}
+	if (!params.positionTicksNull()) {
+		result.addQueryItem("positionTicks", Support::toString<std::optional<qint64>>(params.positionTicks()));
+	}
+	if (!params.audioStreamIndexNull()) {
+		result.addQueryItem("audioStreamIndex", Support::toString<std::optional<qint32>>(params.audioStreamIndex()));
+	}
+	if (!params.subtitleStreamIndexNull()) {
+		result.addQueryItem("subtitleStreamIndex", Support::toString<std::optional<qint32>>(params.subtitleStreamIndex()));
+	}
+	if (!params.volumeLevelNull()) {
+		result.addQueryItem("volumeLevel", Support::toString<std::optional<qint32>>(params.volumeLevel()));
+	}
+	if (!params.playMethodNull()) {
+		result.addQueryItem("playMethod", Support::toString<PlayMethod>(params.playMethod()));
+	}
+	if (!params.liveStreamIdNull()) {
+		result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
+	}
+	if (!params.playSessionIdNull()) {
+		result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
+	}
+	if (!params.repeatModeNull()) {
+		result.addQueryItem("repeatMode", Support::toString<RepeatMode>(params.repeatMode()));
+	}
+	if (!params.isPausedNull()) {
+		result.addQueryItem("isPaused", Support::toString<std::optional<bool>>(params.isPaused()));
+	}
+	if (!params.isMutedNull()) {
+		result.addQueryItem("isMuted", Support::toString<std::optional<bool>>(params.isMuted()));
+	}
+	
+	return result;
+}
+
+QByteArray OnPlaybackProgressLoader::body(const OnPlaybackProgressParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation OnPlaybackProgressLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/plugins.cpp

@@ -64,6 +64,122 @@ QNetworkAccessManager::Operation GetPluginsLoader::operation() const {
 
 }
 
+UninstallPluginLoader::UninstallPluginLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UninstallPluginParams>(apiClient) {}
+
+QString UninstallPluginLoader::path(const UninstallPluginParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) ;
+}
+
+QUrlQuery UninstallPluginLoader::query(const UninstallPluginParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UninstallPluginLoader::body(const UninstallPluginParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation UninstallPluginLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+UninstallPluginByVersionLoader::UninstallPluginByVersionLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UninstallPluginByVersionParams>(apiClient) {}
+
+QString UninstallPluginByVersionLoader::path(const UninstallPluginByVersionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/") + Support::toString< QSharedPointer<Version>>(params.version()) ;
+}
+
+QUrlQuery UninstallPluginByVersionLoader::query(const UninstallPluginByVersionParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UninstallPluginByVersionLoader::body(const UninstallPluginByVersionParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation UninstallPluginByVersionLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
+DisablePluginLoader::DisablePluginLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DisablePluginParams>(apiClient) {}
+
+QString DisablePluginLoader::path(const DisablePluginParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/") + Support::toString< QSharedPointer<Version>>(params.version()) + QStringLiteral("/Disable");
+}
+
+QUrlQuery DisablePluginLoader::query(const DisablePluginParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray DisablePluginLoader::body(const DisablePluginParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DisablePluginLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+EnablePluginLoader::EnablePluginLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, EnablePluginParams>(apiClient) {}
+
+QString EnablePluginLoader::path(const EnablePluginParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/") + Support::toString< QSharedPointer<Version>>(params.version()) + QStringLiteral("/Enable");
+}
+
+QUrlQuery EnablePluginLoader::query(const EnablePluginParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray EnablePluginLoader::body(const EnablePluginParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation EnablePluginLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetPluginConfigurationLoader::GetPluginConfigurationLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<BasePluginConfiguration, GetPluginConfigurationParams>(apiClient) {}
 
@@ -93,6 +209,93 @@ QNetworkAccessManager::Operation GetPluginConfigurationLoader::operation() const
 
 }
 
+UpdatePluginConfigurationLoader::UpdatePluginConfigurationLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdatePluginConfigurationParams>(apiClient) {}
+
+QString UpdatePluginConfigurationLoader::path(const UpdatePluginConfigurationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/Configuration");
+}
+
+QUrlQuery UpdatePluginConfigurationLoader::query(const UpdatePluginConfigurationParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdatePluginConfigurationLoader::body(const UpdatePluginConfigurationParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation UpdatePluginConfigurationLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+GetPluginManifestLoader::GetPluginManifestLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, GetPluginManifestParams>(apiClient) {}
+
+QString GetPluginManifestLoader::path(const GetPluginManifestParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/Manifest");
+}
+
+QUrlQuery GetPluginManifestLoader::query(const GetPluginManifestParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray GetPluginManifestLoader::body(const GetPluginManifestParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation GetPluginManifestLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+UpdatePluginSecurityInfoLoader::UpdatePluginSecurityInfoLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdatePluginSecurityInfoParams>(apiClient) {}
+
+QString UpdatePluginSecurityInfoLoader::path(const UpdatePluginSecurityInfoParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Plugins/SecurityInfo");
+}
+
+QUrlQuery UpdatePluginSecurityInfoLoader::query(const UpdatePluginSecurityInfoParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdatePluginSecurityInfoLoader::body(const UpdatePluginSecurityInfoParams &params) const {
+	return Support::toString<QSharedPointer<PluginSecurityInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdatePluginSecurityInfoLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader

core/src/loader/http/quickconnect.cpp

@@ -35,6 +35,35 @@ namespace HTTP {
 
 using namespace Jellyfin::DTO;
 
+ActivateLoader::ActivateLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, ActivateParams>(apiClient) {}
+
+QString ActivateLoader::path(const ActivateParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/QuickConnect/Activate");
+}
+
+QUrlQuery ActivateLoader::query(const ActivateParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray ActivateLoader::body(const ActivateParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation ActivateLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 AuthorizeLoader::AuthorizeLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<bool, AuthorizeParams>(apiClient) {}
 
@@ -65,6 +94,38 @@ QNetworkAccessManager::Operation AuthorizeLoader::operation() const {
 
 }
 
+AvailableLoader::AvailableLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, AvailableParams>(apiClient) {}
+
+QString AvailableLoader::path(const AvailableParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/QuickConnect/Available");
+}
+
+QUrlQuery AvailableLoader::query(const AvailableParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	if (!params.statusNull()) {
+		result.addQueryItem("status", Support::toString<QuickConnectState>(params.status()));
+	}
+	
+	return result;
+}
+
+QByteArray AvailableLoader::body(const AvailableParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation AvailableLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 ConnectLoader::ConnectLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QuickConnectResult, ConnectParams>(apiClient) {}
 

core/src/loader/http/remoteimage.cpp

@@ -79,6 +79,39 @@ QNetworkAccessManager::Operation GetRemoteImagesLoader::operation() const {
 
 }
 
+DownloadRemoteImageLoader::DownloadRemoteImageLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, DownloadRemoteImageParams>(apiClient) {}
+
+QString DownloadRemoteImageLoader::path(const DownloadRemoteImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/RemoteImages/Download");
+}
+
+QUrlQuery DownloadRemoteImageLoader::query(const DownloadRemoteImageParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+	result.addQueryItem("type", Support::toString<ImageType>(params.type()));
+
+	// Optional parameters
+	if (!params.imageUrlNull()) {
+		result.addQueryItem("imageUrl", Support::toString<QString>(params.imageUrl()));
+	}
+	
+	return result;
+}
+
+QByteArray DownloadRemoteImageLoader::body(const DownloadRemoteImageParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation DownloadRemoteImageLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
 GetRemoteImageProvidersLoader::GetRemoteImageProvidersLoader(ApiClient *apiClient)
 	: Jellyfin::Support::HttpLoader<QList<ImageProviderInfo>, GetRemoteImageProvidersParams>(apiClient) {}
 

core/src/loader/http/scheduledtasks.cpp

@@ -99,6 +99,93 @@ QNetworkAccessManager::Operation GetTaskLoader::operation() const {
 
 }
 
+UpdateTaskLoader::UpdateTaskLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, UpdateTaskParams>(apiClient) {}
+
+QString UpdateTaskLoader::path(const UpdateTaskParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/ScheduledTasks/") + Support::toString< QString>(params.taskId()) + QStringLiteral("/Triggers");
+}
+
+QUrlQuery UpdateTaskLoader::query(const UpdateTaskParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray UpdateTaskLoader::body(const UpdateTaskParams &params) const {
+	return Support::toString<QList<TaskTriggerInfo>>(params.body()).toUtf8();
+}
+
+QNetworkAccessManager::Operation UpdateTaskLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+StartTaskLoader::StartTaskLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, StartTaskParams>(apiClient) {}
+
+QString StartTaskLoader::path(const StartTaskParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/ScheduledTasks/Running/") + Support::toString< QString>(params.taskId()) ;
+}
+
+QUrlQuery StartTaskLoader::query(const StartTaskParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray StartTaskLoader::body(const StartTaskParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation StartTaskLoader::operation() const {
+	// HTTP method Post
+	return QNetworkAccessManager::PostOperation;
+
+}
+
+StopTaskLoader::StopTaskLoader(ApiClient *apiClient)
+	: Jellyfin::Support::HttpLoader<void, StopTaskParams>(apiClient) {}
+
+QString StopTaskLoader::path(const StopTaskParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+	
+	return QStringLiteral("/ScheduledTasks/Running/") + Support::toString< QString>(params.taskId()) ;
+}
+
+QUrlQuery StopTaskLoader::query(const StopTaskParams &params) const {
+	Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
+
+	QUrlQuery result;
+
+	// Optional parameters
+	
+	return result;
+}
+
+QByteArray StopTaskLoader::body(const StopTaskParams &params) const {
+	return QByteArray();
+}
+
+QNetworkAccessManager::Operation StopTaskLoader::operation() const {
+	// HTTP method Delete
+	return QNetworkAccessManager::DeleteOperation;
+
+}
+
 
 } // NS HTTP
 } // NS Loader