// This file is generated by kconfig_compiler_kf6 from settingsmanager.kcfg.
// All changes you do to this file will be lost.
#ifndef SETTINGSMANAGER_H
#define SETTINGSMANAGER_H

#include <kconfigskeleton.h>
#include <QCoreApplication>
#include <QDebug>
#include <qqmlintegration.h>

class QQmlEngine;
class QJSEngine;

class SettingsManager : public KConfigSkeleton
{
  Q_OBJECT
  QML_ELEMENT
  QML_SINGLETON
  public:
    class EnumAutoDeleteOnPlayed
    {
      public:
      enum type { Disabled, Immediately, OnNextStartup, COUNT };
    };
    class EnumMarkUnreadOnNewFeed
    {
      public:
      enum type { None, Custom, All, COUNT };
    };
    class EnumTrayIconType
    {
      public:
      enum type { Colorful, Light, Dark, COUNT };
    };
    class EnumInterfaceMode
    {
      public:
      enum type { Desktop, Mobile, Auto, COUNT };
    };
    class EnumMediabackend
    {
      public:
      enum type { Qt, Vlc, Gst, COUNT };
    };
    class EnumSleepTimerUnits
    {
      public:
      enum type { Seconds, Minutes, Hours, COUNT };
    };
    class EnumProxyType
    {
      public:
      enum type { System, HTTP, Socks5, COUNT };
    };

    static SettingsManager *self();
    static SettingsManager *create(QQmlEngine *, QJSEngine *);
    ~SettingsManager() override;

    /**
      Set Show streaming button instead of download button
    */
    static
    void setPrioritizeStreaming( bool v )
    {
      if (v != self()->mPrioritizeStreaming && !self()->isPrioritizeStreamingImmutable()) {
        self()->mPrioritizeStreaming = v;
        Q_EMIT self()->prioritizeStreamingChanged();
      }
    }

    Q_PROPERTY(bool prioritizeStreaming READ prioritizeStreaming WRITE setPrioritizeStreaming NOTIFY prioritizeStreamingChanged)
    Q_PROPERTY(bool isPrioritizeStreamingImmutable READ isPrioritizeStreamingImmutable CONSTANT)
    Q_PROPERTY(bool defaultPrioritizeStreamingValue READ defaultPrioritizeStreamingValue CONSTANT)
    /**
      Get Show streaming button instead of download button
    */
    static
    bool prioritizeStreaming()
    {
      return self()->mPrioritizeStreaming;
    }

    /**
      Is Show streaming button instead of download button Immutable
    */
    static
    bool isPrioritizeStreamingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "prioritizeStreaming" ) );
    }

    /**
      Get Show streaming button instead of download button default value
    */
    static
    bool defaultPrioritizeStreamingValue()
    {
        return defaultPrioritizeStreamingValue_helper();
    }

    /**
      Set Continue playing next episode after current one finishes
    */
    static
    void setContinuePlayingNextEntry( bool v )
    {
      if (v != self()->mContinuePlayingNextEntry && !self()->isContinuePlayingNextEntryImmutable()) {
        self()->mContinuePlayingNextEntry = v;
        Q_EMIT self()->continuePlayingNextEntryChanged();
      }
    }

    Q_PROPERTY(bool continuePlayingNextEntry READ continuePlayingNextEntry WRITE setContinuePlayingNextEntry NOTIFY continuePlayingNextEntryChanged)
    Q_PROPERTY(bool isContinuePlayingNextEntryImmutable READ isContinuePlayingNextEntryImmutable CONSTANT)
    Q_PROPERTY(bool defaultContinuePlayingNextEntryValue READ defaultContinuePlayingNextEntryValue CONSTANT)
    /**
      Get Continue playing next episode after current one finishes
    */
    static
    bool continuePlayingNextEntry()
    {
      return self()->mContinuePlayingNextEntry;
    }

    /**
      Is Continue playing next episode after current one finishes Immutable
    */
    static
    bool isContinuePlayingNextEntryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "continuePlayingNextEntry" ) );
    }

    /**
      Get Continue playing next episode after current one finishes default value
    */
    static
    bool defaultContinuePlayingNextEntryValue()
    {
        return defaultContinuePlayingNextEntryValue_helper();
    }

    /**
      Set Adjust time left based on the current playback speed
    */
    static
    void setAdjustTimeLeft( bool v )
    {
      if (v != self()->mAdjustTimeLeft && !self()->isAdjustTimeLeftImmutable()) {
        self()->mAdjustTimeLeft = v;
        Q_EMIT self()->adjustTimeLeftChanged();
      }
    }

    Q_PROPERTY(bool adjustTimeLeft READ adjustTimeLeft WRITE setAdjustTimeLeft NOTIFY adjustTimeLeftChanged)
    Q_PROPERTY(bool isAdjustTimeLeftImmutable READ isAdjustTimeLeftImmutable CONSTANT)
    Q_PROPERTY(bool defaultAdjustTimeLeftValue READ defaultAdjustTimeLeftValue CONSTANT)
    /**
      Get Adjust time left based on the current playback speed
    */
    static
    bool adjustTimeLeft()
    {
      return self()->mAdjustTimeLeft;
    }

    /**
      Is Adjust time left based on the current playback speed Immutable
    */
    static
    bool isAdjustTimeLeftImmutable()
    {
      return self()->isImmutable( QStringLiteral( "adjustTimeLeft" ) );
    }

    /**
      Get Adjust time left based on the current playback speed default value
    */
    static
    bool defaultAdjustTimeLeftValue()
    {
        return defaultAdjustTimeLeftValue_helper();
    }

    /**
      Set Automatically fetch feed updates on startup
    */
    static
    void setRefreshOnStartup( bool v )
    {
      if (v != self()->mRefreshOnStartup && !self()->isRefreshOnStartupImmutable()) {
        self()->mRefreshOnStartup = v;
        Q_EMIT self()->refreshOnStartupChanged();
      }
    }

    Q_PROPERTY(bool refreshOnStartup READ refreshOnStartup WRITE setRefreshOnStartup NOTIFY refreshOnStartupChanged)
    Q_PROPERTY(bool isRefreshOnStartupImmutable READ isRefreshOnStartupImmutable CONSTANT)
    Q_PROPERTY(bool defaultRefreshOnStartupValue READ defaultRefreshOnStartupValue CONSTANT)
    /**
      Get Automatically fetch feed updates on startup
    */
    static
    bool refreshOnStartup()
    {
      return self()->mRefreshOnStartup;
    }

    /**
      Is Automatically fetch feed updates on startup Immutable
    */
    static
    bool isRefreshOnStartupImmutable()
    {
      return self()->isImmutable( QStringLiteral( "refreshOnStartup" ) );
    }

    /**
      Get Automatically fetch feed updates on startup default value
    */
    static
    bool defaultRefreshOnStartupValue()
    {
        return defaultRefreshOnStartupValue_helper();
    }

    /**
      Set Update existing entries on feed update
    */
    static
    void setDoFullUpdate( bool v )
    {
      if (v != self()->mDoFullUpdate && !self()->isDoFullUpdateImmutable()) {
        self()->mDoFullUpdate = v;
        Q_EMIT self()->doFullUpdateChanged();
      }
    }

    Q_PROPERTY(bool doFullUpdate READ doFullUpdate WRITE setDoFullUpdate NOTIFY doFullUpdateChanged)
    Q_PROPERTY(bool isDoFullUpdateImmutable READ isDoFullUpdateImmutable CONSTANT)
    Q_PROPERTY(bool defaultDoFullUpdateValue READ defaultDoFullUpdateValue CONSTANT)
    /**
      Get Update existing entries on feed update
    */
    static
    bool doFullUpdate()
    {
      return self()->mDoFullUpdate;
    }

    /**
      Is Update existing entries on feed update Immutable
    */
    static
    bool isDoFullUpdateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "doFullUpdate" ) );
    }

    /**
      Get Update existing entries on feed update default value
    */
    static
    bool defaultDoFullUpdateValue()
    {
        return defaultDoFullUpdateValue_helper();
    }

    /**
      Set Automatically add new episodes to queue
    */
    static
    void setAutoQueue( bool v )
    {
      if (v != self()->mAutoQueue && !self()->isAutoQueueImmutable()) {
        self()->mAutoQueue = v;
        Q_EMIT self()->autoQueueChanged();
      }
    }

    Q_PROPERTY(bool autoQueue READ autoQueue WRITE setAutoQueue NOTIFY autoQueueChanged)
    Q_PROPERTY(bool isAutoQueueImmutable READ isAutoQueueImmutable CONSTANT)
    Q_PROPERTY(bool defaultAutoQueueValue READ defaultAutoQueueValue CONSTANT)
    /**
      Get Automatically add new episodes to queue
    */
    static
    bool autoQueue()
    {
      return self()->mAutoQueue;
    }

    /**
      Is Automatically add new episodes to queue Immutable
    */
    static
    bool isAutoQueueImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoQueue" ) );
    }

    /**
      Get Automatically add new episodes to queue default value
    */
    static
    bool defaultAutoQueueValue()
    {
        return defaultAutoQueueValue_helper();
    }

    /**
      Set Automatically download new episodes
    */
    static
    void setAutoDownload( bool v )
    {
      if (v != self()->mAutoDownload && !self()->isAutoDownloadImmutable()) {
        self()->mAutoDownload = v;
        Q_EMIT self()->autoDownloadChanged();
      }
    }

    Q_PROPERTY(bool autoDownload READ autoDownload WRITE setAutoDownload NOTIFY autoDownloadChanged)
    Q_PROPERTY(bool isAutoDownloadImmutable READ isAutoDownloadImmutable CONSTANT)
    Q_PROPERTY(bool defaultAutoDownloadValue READ defaultAutoDownloadValue CONSTANT)
    /**
      Get Automatically download new episodes
    */
    static
    bool autoDownload()
    {
      return self()->mAutoDownload;
    }

    /**
      Is Automatically download new episodes Immutable
    */
    static
    bool isAutoDownloadImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoDownload" ) );
    }

    /**
      Get Automatically download new episodes default value
    */
    static
    bool defaultAutoDownloadValue()
    {
        return defaultAutoDownloadValue_helper();
    }

    /**
      Set Interval for automatically updating feeds/podcasts. 0 means never update automatically.
    */
    static
    void setAutoFeedUpdateInterval( int v )
    {
      if (v != self()->mAutoFeedUpdateInterval && !self()->isAutoFeedUpdateIntervalImmutable()) {
        self()->mAutoFeedUpdateInterval = v;
        Q_EMIT self()->autoFeedUpdateIntervalChanged();
      }
    }

    Q_PROPERTY(int autoFeedUpdateInterval READ autoFeedUpdateInterval WRITE setAutoFeedUpdateInterval NOTIFY autoFeedUpdateIntervalChanged)
    Q_PROPERTY(bool isAutoFeedUpdateIntervalImmutable READ isAutoFeedUpdateIntervalImmutable CONSTANT)
    Q_PROPERTY(int defaultAutoFeedUpdateIntervalValue READ defaultAutoFeedUpdateIntervalValue CONSTANT)
    /**
      Get Interval for automatically updating feeds/podcasts. 0 means never update automatically.
    */
    static
    int autoFeedUpdateInterval()
    {
      return self()->mAutoFeedUpdateInterval;
    }

    /**
      Is Interval for automatically updating feeds/podcasts. 0 means never update automatically. Immutable
    */
    static
    bool isAutoFeedUpdateIntervalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoFeedUpdateInterval" ) );
    }

    /**
      Get Interval for automatically updating feeds/podcasts. 0 means never update automatically. default value
    */
    static
    int defaultAutoFeedUpdateIntervalValue()
    {
        return defaultAutoFeedUpdateIntervalValue_helper();
    }

    /**
      Set Setting to select if or when to delete played episode
    */
    static
    void setAutoDeleteOnPlayed( int v )
    {
      if (v != self()->mAutoDeleteOnPlayed && !self()->isAutoDeleteOnPlayedImmutable()) {
        self()->mAutoDeleteOnPlayed = v;
        Q_EMIT self()->autoDeleteOnPlayedChanged();
      }
    }

    Q_PROPERTY(int autoDeleteOnPlayed READ autoDeleteOnPlayed WRITE setAutoDeleteOnPlayed NOTIFY autoDeleteOnPlayedChanged)
    Q_PROPERTY(bool isAutoDeleteOnPlayedImmutable READ isAutoDeleteOnPlayedImmutable CONSTANT)
    Q_PROPERTY(int defaultAutoDeleteOnPlayedValue READ defaultAutoDeleteOnPlayedValue CONSTANT)
    /**
      Get Setting to select if or when to delete played episode
    */
    static
    int autoDeleteOnPlayed()
    {
      return self()->mAutoDeleteOnPlayed;
    }

    /**
      Is Setting to select if or when to delete played episode Immutable
    */
    static
    bool isAutoDeleteOnPlayedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoDeleteOnPlayed" ) );
    }

    /**
      Get Setting to select if or when to delete played episode default value
    */
    static
    int defaultAutoDeleteOnPlayedValue()
    {
        return defaultAutoDeleteOnPlayedValue_helper();
    }

    /**
      Set Amount of seconds before end of stream that the episode should already be marked as played
    */
    static
    void setMarkAsPlayedBeforeEnd( int v )
    {
      if (v != self()->mMarkAsPlayedBeforeEnd && !self()->isMarkAsPlayedBeforeEndImmutable()) {
        self()->mMarkAsPlayedBeforeEnd = v;
        Q_EMIT self()->markAsPlayedBeforeEndChanged();
      }
    }

    Q_PROPERTY(int markAsPlayedBeforeEnd READ markAsPlayedBeforeEnd WRITE setMarkAsPlayedBeforeEnd NOTIFY markAsPlayedBeforeEndChanged)
    Q_PROPERTY(bool isMarkAsPlayedBeforeEndImmutable READ isMarkAsPlayedBeforeEndImmutable CONSTANT)
    Q_PROPERTY(int defaultMarkAsPlayedBeforeEndValue READ defaultMarkAsPlayedBeforeEndValue CONSTANT)
    /**
      Get Amount of seconds before end of stream that the episode should already be marked as played
    */
    static
    int markAsPlayedBeforeEnd()
    {
      return self()->mMarkAsPlayedBeforeEnd;
    }

    /**
      Is Amount of seconds before end of stream that the episode should already be marked as played Immutable
    */
    static
    bool isMarkAsPlayedBeforeEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "markAsPlayedBeforeEnd" ) );
    }

    /**
      Get Amount of seconds before end of stream that the episode should already be marked as played default value
    */
    static
    int defaultMarkAsPlayedBeforeEndValue()
    {
        return defaultMarkAsPlayedBeforeEndValue_helper();
    }

    /**
      Set Reset play position when episode is marked as played
    */
    static
    void setResetPositionOnPlayed( bool v )
    {
      if (v != self()->mResetPositionOnPlayed && !self()->isResetPositionOnPlayedImmutable()) {
        self()->mResetPositionOnPlayed = v;
        Q_EMIT self()->resetPositionOnPlayedChanged();
      }
    }

    Q_PROPERTY(bool resetPositionOnPlayed READ resetPositionOnPlayed WRITE setResetPositionOnPlayed NOTIFY resetPositionOnPlayedChanged)
    Q_PROPERTY(bool isResetPositionOnPlayedImmutable READ isResetPositionOnPlayedImmutable CONSTANT)
    Q_PROPERTY(bool defaultResetPositionOnPlayedValue READ defaultResetPositionOnPlayedValue CONSTANT)
    /**
      Get Reset play position when episode is marked as played
    */
    static
    bool resetPositionOnPlayed()
    {
      return self()->mResetPositionOnPlayed;
    }

    /**
      Is Reset play position when episode is marked as played Immutable
    */
    static
    bool isResetPositionOnPlayedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "resetPositionOnPlayed" ) );
    }

    /**
      Get Reset play position when episode is marked as played default value
    */
    static
    bool defaultResetPositionOnPlayedValue()
    {
        return defaultResetPositionOnPlayedValue_helper();
    }

    /**
      Set How many episodes to mark as unread when adding a new feed
    */
    static
    void setMarkUnreadOnNewFeed( int v )
    {
      if (v != self()->mMarkUnreadOnNewFeed && !self()->isMarkUnreadOnNewFeedImmutable()) {
        self()->mMarkUnreadOnNewFeed = v;
        Q_EMIT self()->markUnreadOnNewFeedChanged();
      }
    }

    Q_PROPERTY(int markUnreadOnNewFeed READ markUnreadOnNewFeed WRITE setMarkUnreadOnNewFeed NOTIFY markUnreadOnNewFeedChanged)
    Q_PROPERTY(bool isMarkUnreadOnNewFeedImmutable READ isMarkUnreadOnNewFeedImmutable CONSTANT)
    Q_PROPERTY(int defaultMarkUnreadOnNewFeedValue READ defaultMarkUnreadOnNewFeedValue CONSTANT)
    /**
      Get How many episodes to mark as unread when adding a new feed
    */
    static
    int markUnreadOnNewFeed()
    {
      return self()->mMarkUnreadOnNewFeed;
    }

    /**
      Is How many episodes to mark as unread when adding a new feed Immutable
    */
    static
    bool isMarkUnreadOnNewFeedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "markUnreadOnNewFeed" ) );
    }

    /**
      Get How many episodes to mark as unread when adding a new feed default value
    */
    static
    int defaultMarkUnreadOnNewFeedValue()
    {
        return defaultMarkUnreadOnNewFeedValue_helper();
    }

    /**
      Set Custom number of episodes to mark as unread/unplayed when adding new feed
    */
    static
    void setMarkUnreadOnNewFeedCustomAmount( int v )
    {
      if (v != self()->mMarkUnreadOnNewFeedCustomAmount && !self()->isMarkUnreadOnNewFeedCustomAmountImmutable()) {
        self()->mMarkUnreadOnNewFeedCustomAmount = v;
        Q_EMIT self()->markUnreadOnNewFeedCustomAmountChanged();
      }
    }

    Q_PROPERTY(int markUnreadOnNewFeedCustomAmount READ markUnreadOnNewFeedCustomAmount WRITE setMarkUnreadOnNewFeedCustomAmount NOTIFY markUnreadOnNewFeedCustomAmountChanged)
    Q_PROPERTY(bool isMarkUnreadOnNewFeedCustomAmountImmutable READ isMarkUnreadOnNewFeedCustomAmountImmutable CONSTANT)
    Q_PROPERTY(int defaultMarkUnreadOnNewFeedCustomAmountValue READ defaultMarkUnreadOnNewFeedCustomAmountValue CONSTANT)
    /**
      Get Custom number of episodes to mark as unread/unplayed when adding new feed
    */
    static
    int markUnreadOnNewFeedCustomAmount()
    {
      return self()->mMarkUnreadOnNewFeedCustomAmount;
    }

    /**
      Is Custom number of episodes to mark as unread/unplayed when adding new feed Immutable
    */
    static
    bool isMarkUnreadOnNewFeedCustomAmountImmutable()
    {
      return self()->isImmutable( QStringLiteral( "markUnreadOnNewFeedCustomAmount" ) );
    }

    /**
      Get Custom number of episodes to mark as unread/unplayed when adding new feed default value
    */
    static
    int defaultMarkUnreadOnNewFeedCustomAmountValue()
    {
        return defaultMarkUnreadOnNewFeedCustomAmountValue_helper();
    }

    /**
      Set Whether the player shows remaining track time instead of total track time
    */
    static
    void setToggleRemainingTime( bool v )
    {
      if (v != self()->mToggleRemainingTime && !self()->isToggleRemainingTimeImmutable()) {
        self()->mToggleRemainingTime = v;
        Q_EMIT self()->toggleRemainingTimeChanged();
      }
    }

    Q_PROPERTY(bool toggleRemainingTime READ toggleRemainingTime WRITE setToggleRemainingTime NOTIFY toggleRemainingTimeChanged)
    Q_PROPERTY(bool isToggleRemainingTimeImmutable READ isToggleRemainingTimeImmutable CONSTANT)
    Q_PROPERTY(bool defaultToggleRemainingTimeValue READ defaultToggleRemainingTimeValue CONSTANT)
    /**
      Get Whether the player shows remaining track time instead of total track time
    */
    static
    bool toggleRemainingTime()
    {
      return self()->mToggleRemainingTime;
    }

    /**
      Is Whether the player shows remaining track time instead of total track time Immutable
    */
    static
    bool isToggleRemainingTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "toggleRemainingTime" ) );
    }

    /**
      Get Whether the player shows remaining track time instead of total track time default value
    */
    static
    bool defaultToggleRemainingTimeValue()
    {
        return defaultToggleRemainingTimeValue_helper();
    }

    /**
      Set Article font size
    */
    static
    void setArticleFontSize( int v )
    {
      if (v != self()->mArticleFontSize && !self()->isArticleFontSizeImmutable()) {
        self()->mArticleFontSize = v;
        Q_EMIT self()->articleFontSizeChanged();
      }
    }

    Q_PROPERTY(int articleFontSize READ articleFontSize WRITE setArticleFontSize NOTIFY articleFontSizeChanged)
    Q_PROPERTY(bool isArticleFontSizeImmutable READ isArticleFontSizeImmutable CONSTANT)
    Q_PROPERTY(int defaultArticleFontSizeValue READ defaultArticleFontSizeValue CONSTANT)
    /**
      Get Article font size
    */
    static
    int articleFontSize()
    {
      return self()->mArticleFontSize;
    }

    /**
      Is Article font size Immutable
    */
    static
    bool isArticleFontSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "articleFontSize" ) );
    }

    /**
      Get Article font size default value
    */
    static
    int defaultArticleFontSizeValue()
    {
        return defaultArticleFontSizeValue_helper();
    }

    /**
      Set Custom path to store enclosures and images
    */
    static
    void setStoragePath( const QUrl & v )
    {
      if (v != self()->mStoragePath && !self()->isStoragePathImmutable()) {
        self()->mStoragePath = v;
        Q_EMIT self()->StoragePathChanged();
      }
    }

    Q_PROPERTY(QUrl storagePath READ storagePath WRITE setStoragePath NOTIFY StoragePathChanged)
    Q_PROPERTY(bool isStoragePathImmutable READ isStoragePathImmutable CONSTANT)
    /**
      Get Custom path to store enclosures and images
    */
    static
    QUrl storagePath()
    {
      return self()->mStoragePath;
    }

    /**
      Is Custom path to store enclosures and images Immutable
    */
    static
    bool isStoragePathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StoragePath" ) );
    }

    /**
      Set Always show the title of podcast feeds in subscription view
    */
    static
    void setAlwaysShowFeedTitles( bool v )
    {
      if (v != self()->mAlwaysShowFeedTitles && !self()->isAlwaysShowFeedTitlesImmutable()) {
        self()->mAlwaysShowFeedTitles = v;
        Q_EMIT self()->alwaysShowFeedTitlesChanged();
      }
    }

    Q_PROPERTY(bool alwaysShowFeedTitles READ alwaysShowFeedTitles WRITE setAlwaysShowFeedTitles NOTIFY alwaysShowFeedTitlesChanged)
    Q_PROPERTY(bool isAlwaysShowFeedTitlesImmutable READ isAlwaysShowFeedTitlesImmutable CONSTANT)
    Q_PROPERTY(bool defaultAlwaysShowFeedTitlesValue READ defaultAlwaysShowFeedTitlesValue CONSTANT)
    /**
      Get Always show the title of podcast feeds in subscription view
    */
    static
    bool alwaysShowFeedTitles()
    {
      return self()->mAlwaysShowFeedTitles;
    }

    /**
      Is Always show the title of podcast feeds in subscription view Immutable
    */
    static
    bool isAlwaysShowFeedTitlesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "alwaysShowFeedTitles" ) );
    }

    /**
      Get Always show the title of podcast feeds in subscription view default value
    */
    static
    bool defaultAlwaysShowFeedTitlesValue()
    {
        return defaultAlwaysShowFeedTitlesValue_helper();
    }

    /**
      Set Show the image of the episode rather than the general podcast image
    */
    static
    void setShowEpisodeImage( bool v )
    {
      if (v != self()->mShowEpisodeImage && !self()->isShowEpisodeImageImmutable()) {
        self()->mShowEpisodeImage = v;
        Q_EMIT self()->showEpisodeImageChanged();
      }
    }

    Q_PROPERTY(bool showEpisodeImage READ showEpisodeImage WRITE setShowEpisodeImage NOTIFY showEpisodeImageChanged)
    Q_PROPERTY(bool isShowEpisodeImageImmutable READ isShowEpisodeImageImmutable CONSTANT)
    Q_PROPERTY(bool defaultShowEpisodeImageValue READ defaultShowEpisodeImageValue CONSTANT)
    /**
      Get Show the image of the episode rather than the general podcast image
    */
    static
    bool showEpisodeImage()
    {
      return self()->mShowEpisodeImage;
    }

    /**
      Is Show the image of the episode rather than the general podcast image Immutable
    */
    static
    bool isShowEpisodeImageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showEpisodeImage" ) );
    }

    /**
      Get Show the image of the episode rather than the general podcast image default value
    */
    static
    bool defaultShowEpisodeImageValue()
    {
        return defaultShowEpisodeImageValue_helper();
    }

    /**
      Set Show the podcast/feed title on the entry delegate
    */
    static
    void setShowPodcastTitle( bool v )
    {
      if (v != self()->mShowPodcastTitle && !self()->isShowPodcastTitleImmutable()) {
        self()->mShowPodcastTitle = v;
        Q_EMIT self()->showPodcastTitleChanged();
      }
    }

    Q_PROPERTY(bool showPodcastTitle READ showPodcastTitle WRITE setShowPodcastTitle NOTIFY showPodcastTitleChanged)
    Q_PROPERTY(bool isShowPodcastTitleImmutable READ isShowPodcastTitleImmutable CONSTANT)
    Q_PROPERTY(bool defaultShowPodcastTitleValue READ defaultShowPodcastTitleValue CONSTANT)
    /**
      Get Show the podcast/feed title on the entry delegate
    */
    static
    bool showPodcastTitle()
    {
      return self()->mShowPodcastTitle;
    }

    /**
      Is Show the podcast/feed title on the entry delegate Immutable
    */
    static
    bool isShowPodcastTitleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showPodcastTitle" ) );
    }

    /**
      Get Show the podcast/feed title on the entry delegate default value
    */
    static
    bool defaultShowPodcastTitleValue()
    {
        return defaultShowPodcastTitleValue_helper();
    }

    /**
      Set Show icon in system tray
    */
    static
    void setShowTrayIcon( bool v )
    {
      if (v != self()->mShowTrayIcon && !self()->isShowTrayIconImmutable()) {
        self()->mShowTrayIcon = v;
        Q_EMIT self()->showTrayIconChanged();
      }
    }

    Q_PROPERTY(bool showTrayIcon READ showTrayIcon WRITE setShowTrayIcon NOTIFY showTrayIconChanged)
    Q_PROPERTY(bool isShowTrayIconImmutable READ isShowTrayIconImmutable CONSTANT)
    Q_PROPERTY(bool defaultShowTrayIconValue READ defaultShowTrayIconValue CONSTANT)
    /**
      Get Show icon in system tray
    */
    static
    bool showTrayIcon()
    {
      return self()->mShowTrayIcon;
    }

    /**
      Is Show icon in system tray Immutable
    */
    static
    bool isShowTrayIconImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showTrayIcon" ) );
    }

    /**
      Get Show icon in system tray default value
    */
    static
    bool defaultShowTrayIconValue()
    {
        return defaultShowTrayIconValue_helper();
    }

    /**
      Set Color/type of the tray icon
    */
    static
    void setTrayIconType( int v )
    {
      if (v != self()->mTrayIconType && !self()->isTrayIconTypeImmutable()) {
        self()->mTrayIconType = v;
        Q_EMIT self()->trayIconTypeChanged();
      }
    }

    Q_PROPERTY(int trayIconType READ trayIconType WRITE setTrayIconType NOTIFY trayIconTypeChanged)
    Q_PROPERTY(bool isTrayIconTypeImmutable READ isTrayIconTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultTrayIconTypeValue READ defaultTrayIconTypeValue CONSTANT)
    /**
      Get Color/type of the tray icon
    */
    static
    int trayIconType()
    {
      return self()->mTrayIconType;
    }

    /**
      Is Color/type of the tray icon Immutable
    */
    static
    bool isTrayIconTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "trayIconType" ) );
    }

    /**
      Get Color/type of the tray icon default value
    */
    static
    int defaultTrayIconTypeValue()
    {
        return defaultTrayIconTypeValue_helper();
    }

    /**
      Set Minimize to system tray instead of closing application
    */
    static
    void setMinimizeToTray( bool v )
    {
      if (v != self()->mMinimizeToTray && !self()->isMinimizeToTrayImmutable()) {
        self()->mMinimizeToTray = v;
        Q_EMIT self()->minimizeToTrayChanged();
      }
    }

    Q_PROPERTY(bool minimizeToTray READ minimizeToTray WRITE setMinimizeToTray NOTIFY minimizeToTrayChanged)
    Q_PROPERTY(bool isMinimizeToTrayImmutable READ isMinimizeToTrayImmutable CONSTANT)
    Q_PROPERTY(bool defaultMinimizeToTrayValue READ defaultMinimizeToTrayValue CONSTANT)
    /**
      Get Minimize to system tray instead of closing application
    */
    static
    bool minimizeToTray()
    {
      return self()->mMinimizeToTray;
    }

    /**
      Is Minimize to system tray instead of closing application Immutable
    */
    static
    bool isMinimizeToTrayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "minimizeToTray" ) );
    }

    /**
      Get Minimize to system tray instead of closing application default value
    */
    static
    bool defaultMinimizeToTrayValue()
    {
        return defaultMinimizeToTrayValue_helper();
    }

    /**
      Set Use default system font
    */
    static
    void setArticleFontUseSystem( bool v )
    {
      if (v != self()->mArticleFontUseSystem && !self()->isArticleFontUseSystemImmutable()) {
        self()->mArticleFontUseSystem = v;
        Q_EMIT self()->articleFontUseSystemChanged();
      }
    }

    Q_PROPERTY(bool articleFontUseSystem READ articleFontUseSystem WRITE setArticleFontUseSystem NOTIFY articleFontUseSystemChanged)
    Q_PROPERTY(bool isArticleFontUseSystemImmutable READ isArticleFontUseSystemImmutable CONSTANT)
    Q_PROPERTY(bool defaultArticleFontUseSystemValue READ defaultArticleFontUseSystemValue CONSTANT)
    /**
      Get Use default system font
    */
    static
    bool articleFontUseSystem()
    {
      return self()->mArticleFontUseSystem;
    }

    /**
      Is Use default system font Immutable
    */
    static
    bool isArticleFontUseSystemImmutable()
    {
      return self()->isImmutable( QStringLiteral( "articleFontUseSystem" ) );
    }

    /**
      Get Use default system font default value
    */
    static
    bool defaultArticleFontUseSystemValue()
    {
        return defaultArticleFontUseSystemValue_helper();
    }

    /**
      Set Which interface to show: automatic, desktop or mobile
    */
    static
    void setInterfaceMode( int v )
    {
      if (v != self()->mInterfaceMode && !self()->isInterfaceModeImmutable()) {
        self()->mInterfaceMode = v;
        Q_EMIT self()->interfaceModeChanged();
      }
    }

    Q_PROPERTY(int interfaceMode READ interfaceMode WRITE setInterfaceMode NOTIFY interfaceModeChanged)
    Q_PROPERTY(bool isInterfaceModeImmutable READ isInterfaceModeImmutable CONSTANT)
    Q_PROPERTY(int defaultInterfaceModeValue READ defaultInterfaceModeValue CONSTANT)
    /**
      Get Which interface to show: automatic, desktop or mobile
    */
    static
    int interfaceMode()
    {
      return self()->mInterfaceMode;
    }

    /**
      Is Which interface to show: automatic, desktop or mobile Immutable
    */
    static
    bool isInterfaceModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "interfaceMode" ) );
    }

    /**
      Get Which interface to show: automatic, desktop or mobile default value
    */
    static
    int defaultInterfaceModeValue()
    {
        return defaultInterfaceModeValue_helper();
    }

    /**
      Set Media backend to use for playback
    */
    static
    void setMediabackend( int v )
    {
      if (v != self()->mMediabackend && !self()->isMediabackendImmutable()) {
        self()->mMediabackend = v;
        Q_EMIT self()->mediabackendChanged();
      }
    }

    Q_PROPERTY(int mediabackend READ mediabackend WRITE setMediabackend NOTIFY mediabackendChanged)
    Q_PROPERTY(bool isMediabackendImmutable READ isMediabackendImmutable CONSTANT)
    Q_PROPERTY(int defaultMediabackendValue READ defaultMediabackendValue CONSTANT)
    /**
      Get Media backend to use for playback
    */
    static
    int mediabackend()
    {
      return self()->mMediabackend;
    }

    /**
      Is Media backend to use for playback Immutable
    */
    static
    bool isMediabackendImmutable()
    {
      return self()->isImmutable( QStringLiteral( "mediabackend" ) );
    }

    /**
      Get Media backend to use for playback default value
    */
    static
    int defaultMediabackendValue()
    {
        return defaultMediabackendValue_helper();
    }

    /**
      Set List of user-defined playback rates
    */
    static
    void setPlaybackRates( const QList<int> & v )
    {
      if (v != self()->mPlaybackRates && !self()->isPlaybackRatesImmutable()) {
        self()->mPlaybackRates = v;
        Q_EMIT self()->playbackRatesChanged();
      }
    }

    Q_PROPERTY(QList<int> playbackRates READ playbackRates WRITE setPlaybackRates NOTIFY playbackRatesChanged)
    Q_PROPERTY(bool isPlaybackRatesImmutable READ isPlaybackRatesImmutable CONSTANT)
    Q_PROPERTY(QList<int> defaultPlaybackRatesValue READ defaultPlaybackRatesValue CONSTANT)
    /**
      Get List of user-defined playback rates
    */
    static
    QList<int> playbackRates()
    {
      return self()->mPlaybackRates;
    }

    /**
      Is List of user-defined playback rates Immutable
    */
    static
    bool isPlaybackRatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "playbackRates" ) );
    }

    /**
      Get List of user-defined playback rates default value
    */
    static
    QList<int> defaultPlaybackRatesValue()
    {
        return defaultPlaybackRatesValue_helper();
    }

    /**
      Set Skip forward in seconds
    */
    static
    void setSkipForward( uint v )
    {
      if (v < 1)
      {
        qDebug() << "setSkipForward: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

      if (v > 300)
      {
        qDebug() << "setSkipForward: value " << v << " is greater than the maximum value of 300";
        v = 300;
      }

      if (v != self()->mSkipForward && !self()->isSkipForwardImmutable()) {
        self()->mSkipForward = v;
        Q_EMIT self()->skipForwardChanged();
      }
    }

    Q_PROPERTY(uint skipForward READ skipForward WRITE setSkipForward NOTIFY skipForwardChanged)
    Q_PROPERTY(bool isSkipForwardImmutable READ isSkipForwardImmutable CONSTANT)
    Q_PROPERTY(uint defaultSkipForwardValue READ defaultSkipForwardValue CONSTANT)
    /**
      Get Skip forward in seconds
    */
    static
    uint skipForward()
    {
      return self()->mSkipForward;
    }

    /**
      Is Skip forward in seconds Immutable
    */
    static
    bool isSkipForwardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "skipForward" ) );
    }

    /**
      Get Skip forward in seconds default value
    */
    static
    uint defaultSkipForwardValue()
    {
        return defaultSkipForwardValue_helper();
    }

    /**
      Set Skip backward in seconds
    */
    static
    void setSkipBackward( uint v )
    {
      if (v < 1)
      {
        qDebug() << "setSkipBackward: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

      if (v > 300)
      {
        qDebug() << "setSkipBackward: value " << v << " is greater than the maximum value of 300";
        v = 300;
      }

      if (v != self()->mSkipBackward && !self()->isSkipBackwardImmutable()) {
        self()->mSkipBackward = v;
        Q_EMIT self()->skipBackwardChanged();
      }
    }

    Q_PROPERTY(uint skipBackward READ skipBackward WRITE setSkipBackward NOTIFY skipBackwardChanged)
    Q_PROPERTY(bool isSkipBackwardImmutable READ isSkipBackwardImmutable CONSTANT)
    Q_PROPERTY(uint defaultSkipBackwardValue READ defaultSkipBackwardValue CONSTANT)
    /**
      Get Skip backward in seconds
    */
    static
    uint skipBackward()
    {
      return self()->mSkipBackward;
    }

    /**
      Is Skip backward in seconds Immutable
    */
    static
    bool isSkipBackwardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "skipBackward" ) );
    }

    /**
      Get Skip backward in seconds default value
    */
    static
    uint defaultSkipBackwardValue()
    {
        return defaultSkipBackwardValue_helper();
    }

    /**
      Set Maximum amount of parallel episode downloads
    */
    static
    void setMaximumParallelEpisodeDownloads( int v )
    {
      if (v != self()->mMaximumParallelEpisodeDownloads && !self()->isMaximumParallelEpisodeDownloadsImmutable()) {
        self()->mMaximumParallelEpisodeDownloads = v;
        Q_EMIT self()->maximumParallelEpisodeDownloadsChanged();
      }
    }

    Q_PROPERTY(int maximumParallelEpisodeDownloads READ maximumParallelEpisodeDownloads WRITE setMaximumParallelEpisodeDownloads NOTIFY maximumParallelEpisodeDownloadsChanged)
    Q_PROPERTY(bool isMaximumParallelEpisodeDownloadsImmutable READ isMaximumParallelEpisodeDownloadsImmutable CONSTANT)
    Q_PROPERTY(int defaultMaximumParallelEpisodeDownloadsValue READ defaultMaximumParallelEpisodeDownloadsValue CONSTANT)
    /**
      Get Maximum amount of parallel episode downloads
    */
    static
    int maximumParallelEpisodeDownloads()
    {
      return self()->mMaximumParallelEpisodeDownloads;
    }

    /**
      Is Maximum amount of parallel episode downloads Immutable
    */
    static
    bool isMaximumParallelEpisodeDownloadsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "maximumParallelEpisodeDownloads" ) );
    }

    /**
      Get Maximum amount of parallel episode downloads default value
    */
    static
    int defaultMaximumParallelEpisodeDownloadsValue()
    {
        return defaultMaximumParallelEpisodeDownloadsValue_helper();
    }

    /**
      Set Check for network and metered connection status
    */
    static
    void setCheckNetworkStatus( bool v )
    {
      if (v != self()->mCheckNetworkStatus && !self()->isCheckNetworkStatusImmutable()) {
        self()->mCheckNetworkStatus = v;
        Q_EMIT self()->checkNetworkStatusChanged();
      }
    }

    Q_PROPERTY(bool checkNetworkStatus READ checkNetworkStatus WRITE setCheckNetworkStatus NOTIFY checkNetworkStatusChanged)
    Q_PROPERTY(bool isCheckNetworkStatusImmutable READ isCheckNetworkStatusImmutable CONSTANT)
    Q_PROPERTY(bool defaultCheckNetworkStatusValue READ defaultCheckNetworkStatusValue CONSTANT)
    /**
      Get Check for network and metered connection status
    */
    static
    bool checkNetworkStatus()
    {
      return self()->mCheckNetworkStatus;
    }

    /**
      Is Check for network and metered connection status Immutable
    */
    static
    bool isCheckNetworkStatusImmutable()
    {
      return self()->isImmutable( QStringLiteral( "checkNetworkStatus" ) );
    }

    /**
      Get Check for network and metered connection status default value
    */
    static
    bool defaultCheckNetworkStatusValue()
    {
        return defaultCheckNetworkStatusValue_helper();
    }

    /**
      Set Allow podcast updates on metered connections
    */
    static
    void setAllowMeteredFeedUpdates( bool v )
    {
      if (v != self()->mAllowMeteredFeedUpdates && !self()->isAllowMeteredFeedUpdatesImmutable()) {
        self()->mAllowMeteredFeedUpdates = v;
        Q_EMIT self()->allowMeteredFeedUpdatesChanged();
      }
    }

    Q_PROPERTY(bool allowMeteredFeedUpdates READ allowMeteredFeedUpdates WRITE setAllowMeteredFeedUpdates NOTIFY allowMeteredFeedUpdatesChanged)
    Q_PROPERTY(bool isAllowMeteredFeedUpdatesImmutable READ isAllowMeteredFeedUpdatesImmutable CONSTANT)
    Q_PROPERTY(bool defaultAllowMeteredFeedUpdatesValue READ defaultAllowMeteredFeedUpdatesValue CONSTANT)
    /**
      Get Allow podcast updates on metered connections
    */
    static
    bool allowMeteredFeedUpdates()
    {
      return self()->mAllowMeteredFeedUpdates;
    }

    /**
      Is Allow podcast updates on metered connections Immutable
    */
    static
    bool isAllowMeteredFeedUpdatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "allowMeteredFeedUpdates" ) );
    }

    /**
      Get Allow podcast updates on metered connections default value
    */
    static
    bool defaultAllowMeteredFeedUpdatesValue()
    {
        return defaultAllowMeteredFeedUpdatesValue_helper();
    }

    /**
      Set Allow podcast downloads on metered connections
    */
    static
    void setAllowMeteredEpisodeDownloads( bool v )
    {
      if (v != self()->mAllowMeteredEpisodeDownloads && !self()->isAllowMeteredEpisodeDownloadsImmutable()) {
        self()->mAllowMeteredEpisodeDownloads = v;
        Q_EMIT self()->allowMeteredEpisodeDownloadsChanged();
      }
    }

    Q_PROPERTY(bool allowMeteredEpisodeDownloads READ allowMeteredEpisodeDownloads WRITE setAllowMeteredEpisodeDownloads NOTIFY allowMeteredEpisodeDownloadsChanged)
    Q_PROPERTY(bool isAllowMeteredEpisodeDownloadsImmutable READ isAllowMeteredEpisodeDownloadsImmutable CONSTANT)
    Q_PROPERTY(bool defaultAllowMeteredEpisodeDownloadsValue READ defaultAllowMeteredEpisodeDownloadsValue CONSTANT)
    /**
      Get Allow podcast downloads on metered connections
    */
    static
    bool allowMeteredEpisodeDownloads()
    {
      return self()->mAllowMeteredEpisodeDownloads;
    }

    /**
      Is Allow podcast downloads on metered connections Immutable
    */
    static
    bool isAllowMeteredEpisodeDownloadsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "allowMeteredEpisodeDownloads" ) );
    }

    /**
      Get Allow podcast downloads on metered connections default value
    */
    static
    bool defaultAllowMeteredEpisodeDownloadsValue()
    {
        return defaultAllowMeteredEpisodeDownloadsValue_helper();
    }

    /**
      Set Allow image downloads on metered connections
    */
    static
    void setAllowMeteredImageDownloads( bool v )
    {
      if (v != self()->mAllowMeteredImageDownloads && !self()->isAllowMeteredImageDownloadsImmutable()) {
        self()->mAllowMeteredImageDownloads = v;
        Q_EMIT self()->allowMeteredImageDownloadsChanged();
      }
    }

    Q_PROPERTY(bool allowMeteredImageDownloads READ allowMeteredImageDownloads WRITE setAllowMeteredImageDownloads NOTIFY allowMeteredImageDownloadsChanged)
    Q_PROPERTY(bool isAllowMeteredImageDownloadsImmutable READ isAllowMeteredImageDownloadsImmutable CONSTANT)
    Q_PROPERTY(bool defaultAllowMeteredImageDownloadsValue READ defaultAllowMeteredImageDownloadsValue CONSTANT)
    /**
      Get Allow image downloads on metered connections
    */
    static
    bool allowMeteredImageDownloads()
    {
      return self()->mAllowMeteredImageDownloads;
    }

    /**
      Is Allow image downloads on metered connections Immutable
    */
    static
    bool isAllowMeteredImageDownloadsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "allowMeteredImageDownloads" ) );
    }

    /**
      Get Allow image downloads on metered connections default value
    */
    static
    bool defaultAllowMeteredImageDownloadsValue()
    {
        return defaultAllowMeteredImageDownloadsValue_helper();
    }

    /**
      Set Allow streaming on metered connections
    */
    static
    void setAllowMeteredStreaming( bool v )
    {
      if (v != self()->mAllowMeteredStreaming && !self()->isAllowMeteredStreamingImmutable()) {
        self()->mAllowMeteredStreaming = v;
        Q_EMIT self()->allowMeteredStreamingChanged();
      }
    }

    Q_PROPERTY(bool allowMeteredStreaming READ allowMeteredStreaming WRITE setAllowMeteredStreaming NOTIFY allowMeteredStreamingChanged)
    Q_PROPERTY(bool isAllowMeteredStreamingImmutable READ isAllowMeteredStreamingImmutable CONSTANT)
    Q_PROPERTY(bool defaultAllowMeteredStreamingValue READ defaultAllowMeteredStreamingValue CONSTANT)
    /**
      Get Allow streaming on metered connections
    */
    static
    bool allowMeteredStreaming()
    {
      return self()->mAllowMeteredStreaming;
    }

    /**
      Is Allow streaming on metered connections Immutable
    */
    static
    bool isAllowMeteredStreamingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "allowMeteredStreaming" ) );
    }

    /**
      Get Allow streaming on metered connections default value
    */
    static
    bool defaultAllowMeteredStreamingValue()
    {
        return defaultAllowMeteredStreamingValue_helper();
    }

    /**
      Set The number of seconds/minutes/hours to set the sleep timer to
    */
    static
    void setSleepTimerValue( int v )
    {
      if (v != self()->mSleepTimerValue && !self()->isSleepTimerValueImmutable()) {
        self()->mSleepTimerValue = v;
        Q_EMIT self()->sleepTimerValueChanged();
      }
    }

    Q_PROPERTY(int sleepTimerValue READ sleepTimerValue WRITE setSleepTimerValue NOTIFY sleepTimerValueChanged)
    Q_PROPERTY(bool isSleepTimerValueImmutable READ isSleepTimerValueImmutable CONSTANT)
    Q_PROPERTY(int defaultSleepTimerValueValue READ defaultSleepTimerValueValue CONSTANT)
    /**
      Get The number of seconds/minutes/hours to set the sleep timer to
    */
    static
    int sleepTimerValue()
    {
      return self()->mSleepTimerValue;
    }

    /**
      Is The number of seconds/minutes/hours to set the sleep timer to Immutable
    */
    static
    bool isSleepTimerValueImmutable()
    {
      return self()->isImmutable( QStringLiteral( "sleepTimerValue" ) );
    }

    /**
      Get The number of seconds/minutes/hours to set the sleep timer to default value
    */
    static
    int defaultSleepTimerValueValue()
    {
        return defaultSleepTimerValueValue_helper();
    }

    /**
      Set The units for the sleepTimerValue
    */
    static
    void setSleepTimerUnits( int v )
    {
      if (v != self()->mSleepTimerUnits && !self()->isSleepTimerUnitsImmutable()) {
        self()->mSleepTimerUnits = v;
        Q_EMIT self()->sleepTimerUnitsChanged();
      }
    }

    Q_PROPERTY(int sleepTimerUnits READ sleepTimerUnits WRITE setSleepTimerUnits NOTIFY sleepTimerUnitsChanged)
    Q_PROPERTY(bool isSleepTimerUnitsImmutable READ isSleepTimerUnitsImmutable CONSTANT)
    Q_PROPERTY(int defaultSleepTimerUnitsValue READ defaultSleepTimerUnitsValue CONSTANT)
    /**
      Get The units for the sleepTimerValue
    */
    static
    int sleepTimerUnits()
    {
      return self()->mSleepTimerUnits;
    }

    /**
      Is The units for the sleepTimerValue Immutable
    */
    static
    bool isSleepTimerUnitsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "sleepTimerUnits" ) );
    }

    /**
      Get The units for the sleepTimerValue default value
    */
    static
    int defaultSleepTimerUnitsValue()
    {
        return defaultSleepTimerUnitsValue_helper();
    }

    /**
      Set Whether or not sync is active
    */
    static
    void setSyncEnabled( bool v )
    {
      if (v != self()->mSyncEnabled && !self()->isSyncEnabledImmutable()) {
        self()->mSyncEnabled = v;
        Q_EMIT self()->syncEnabledChanged();
      }
    }

    Q_PROPERTY(bool syncEnabled READ syncEnabled WRITE setSyncEnabled NOTIFY syncEnabledChanged)
    Q_PROPERTY(bool isSyncEnabledImmutable READ isSyncEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultSyncEnabledValue READ defaultSyncEnabledValue CONSTANT)
    /**
      Get Whether or not sync is active
    */
    static
    bool syncEnabled()
    {
      return self()->mSyncEnabled;
    }

    /**
      Is Whether or not sync is active Immutable
    */
    static
    bool isSyncEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncEnabled" ) );
    }

    /**
      Get Whether or not sync is active default value
    */
    static
    bool defaultSyncEnabledValue()
    {
        return defaultSyncEnabledValue_helper();
    }

    /**
      Set Whether to sync when a feed update is triggered
    */
    static
    void setSyncWhenUpdatingFeeds( bool v )
    {
      if (v != self()->mSyncWhenUpdatingFeeds && !self()->isSyncWhenUpdatingFeedsImmutable()) {
        self()->mSyncWhenUpdatingFeeds = v;
        Q_EMIT self()->syncWhenUpdatingFeedsChanged();
      }
    }

    Q_PROPERTY(bool syncWhenUpdatingFeeds READ syncWhenUpdatingFeeds WRITE setSyncWhenUpdatingFeeds NOTIFY syncWhenUpdatingFeedsChanged)
    Q_PROPERTY(bool isSyncWhenUpdatingFeedsImmutable READ isSyncWhenUpdatingFeedsImmutable CONSTANT)
    Q_PROPERTY(bool defaultSyncWhenUpdatingFeedsValue READ defaultSyncWhenUpdatingFeedsValue CONSTANT)
    /**
      Get Whether to sync when a feed update is triggered
    */
    static
    bool syncWhenUpdatingFeeds()
    {
      return self()->mSyncWhenUpdatingFeeds;
    }

    /**
      Is Whether to sync when a feed update is triggered Immutable
    */
    static
    bool isSyncWhenUpdatingFeedsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncWhenUpdatingFeeds" ) );
    }

    /**
      Get Whether to sync when a feed update is triggered default value
    */
    static
    bool defaultSyncWhenUpdatingFeedsValue()
    {
        return defaultSyncWhenUpdatingFeedsValue_helper();
    }

    /**
      Set Whether to do a quick sync when the audio player state changes
    */
    static
    void setSyncWhenPlayerstateChanges( bool v )
    {
      if (v != self()->mSyncWhenPlayerstateChanges && !self()->isSyncWhenPlayerstateChangesImmutable()) {
        self()->mSyncWhenPlayerstateChanges = v;
        Q_EMIT self()->syncWhenPlayerstateChangesChanged();
      }
    }

    Q_PROPERTY(bool syncWhenPlayerstateChanges READ syncWhenPlayerstateChanges WRITE setSyncWhenPlayerstateChanges NOTIFY syncWhenPlayerstateChangesChanged)
    Q_PROPERTY(bool isSyncWhenPlayerstateChangesImmutable READ isSyncWhenPlayerstateChangesImmutable CONSTANT)
    Q_PROPERTY(bool defaultSyncWhenPlayerstateChangesValue READ defaultSyncWhenPlayerstateChangesValue CONSTANT)
    /**
      Get Whether to do a quick sync when the audio player state changes
    */
    static
    bool syncWhenPlayerstateChanges()
    {
      return self()->mSyncWhenPlayerstateChanges;
    }

    /**
      Is Whether to do a quick sync when the audio player state changes Immutable
    */
    static
    bool isSyncWhenPlayerstateChangesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncWhenPlayerstateChanges" ) );
    }

    /**
      Get Whether to do a quick sync when the audio player state changes default value
    */
    static
    bool defaultSyncWhenPlayerstateChangesValue()
    {
        return defaultSyncWhenPlayerstateChangesValue_helper();
    }

    /**
      Set Which service to sync to; see enum Sync::Provider
    */
    static
    void setSyncProvider( int v )
    {
      if (v != self()->mSyncProvider && !self()->isSyncProviderImmutable()) {
        self()->mSyncProvider = v;
        Q_EMIT self()->syncProviderChanged();
      }
    }

    Q_PROPERTY(int syncProvider READ syncProvider WRITE setSyncProvider NOTIFY syncProviderChanged)
    Q_PROPERTY(bool isSyncProviderImmutable READ isSyncProviderImmutable CONSTANT)
    Q_PROPERTY(int defaultSyncProviderValue READ defaultSyncProviderValue CONSTANT)
    /**
      Get Which service to sync to; see enum Sync::Provider
    */
    static
    int syncProvider()
    {
      return self()->mSyncProvider;
    }

    /**
      Is Which service to sync to; see enum Sync::Provider Immutable
    */
    static
    bool isSyncProviderImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncProvider" ) );
    }

    /**
      Get Which service to sync to; see enum Sync::Provider default value
    */
    static
    int defaultSyncProviderValue()
    {
        return defaultSyncProviderValue_helper();
    }

    /**
      Set Hostname for sync service
    */
    static
    void setSyncHostname( const QString & v )
    {
      if (v != self()->mSyncHostname && !self()->isSyncHostnameImmutable()) {
        self()->mSyncHostname = v;
        Q_EMIT self()->syncHostnameChanged();
      }
    }

    Q_PROPERTY(QString syncHostname READ syncHostname WRITE setSyncHostname NOTIFY syncHostnameChanged)
    Q_PROPERTY(bool isSyncHostnameImmutable READ isSyncHostnameImmutable CONSTANT)
    /**
      Get Hostname for sync service
    */
    static
    QString syncHostname()
    {
      return self()->mSyncHostname;
    }

    /**
      Is Hostname for sync service Immutable
    */
    static
    bool isSyncHostnameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncHostname" ) );
    }

    /**
      Set Username to log into sync service
    */
    static
    void setSyncUsername( const QString & v )
    {
      if (v != self()->mSyncUsername && !self()->isSyncUsernameImmutable()) {
        self()->mSyncUsername = v;
        Q_EMIT self()->syncUsernameChanged();
      }
    }

    Q_PROPERTY(QString syncUsername READ syncUsername WRITE setSyncUsername NOTIFY syncUsernameChanged)
    Q_PROPERTY(bool isSyncUsernameImmutable READ isSyncUsernameImmutable CONSTANT)
    /**
      Get Username to log into sync service
    */
    static
    QString syncUsername()
    {
      return self()->mSyncUsername;
    }

    /**
      Is Username to log into sync service Immutable
    */
    static
    bool isSyncUsernameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncUsername" ) );
    }

    /**
      Set Device id with which to log into sync service
    */
    static
    void setSyncDevice( const QString & v )
    {
      if (v != self()->mSyncDevice && !self()->isSyncDeviceImmutable()) {
        self()->mSyncDevice = v;
        Q_EMIT self()->syncDeviceChanged();
      }
    }

    Q_PROPERTY(QString syncDevice READ syncDevice WRITE setSyncDevice NOTIFY syncDeviceChanged)
    Q_PROPERTY(bool isSyncDeviceImmutable READ isSyncDeviceImmutable CONSTANT)
    /**
      Get Device id with which to log into sync service
    */
    static
    QString syncDevice()
    {
      return self()->mSyncDevice;
    }

    /**
      Is Device id with which to log into sync service Immutable
    */
    static
    bool isSyncDeviceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncDevice" ) );
    }

    /**
      Set Device name (caption) with which to log into sync service
    */
    static
    void setSyncDeviceName( const QString & v )
    {
      if (v != self()->mSyncDeviceName && !self()->isSyncDeviceNameImmutable()) {
        self()->mSyncDeviceName = v;
        Q_EMIT self()->syncDeviceNameChanged();
      }
    }

    Q_PROPERTY(QString syncDeviceName READ syncDeviceName WRITE setSyncDeviceName NOTIFY syncDeviceNameChanged)
    Q_PROPERTY(bool isSyncDeviceNameImmutable READ isSyncDeviceNameImmutable CONSTANT)
    /**
      Get Device name (caption) with which to log into sync service
    */
    static
    QString syncDeviceName()
    {
      return self()->mSyncDeviceName;
    }

    /**
      Is Device name (caption) with which to log into sync service Immutable
    */
    static
    bool isSyncDeviceNameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncDeviceName" ) );
    }

    /**
      Set The type of proxy used by the application
    */
    static
    void setProxyType( int v )
    {
      if (v != self()->mProxyType && !self()->isProxyTypeImmutable()) {
        self()->mProxyType = v;
        Q_EMIT self()->ProxyTypeChanged();
      }
    }

    Q_PROPERTY(int proxyType READ proxyType WRITE setProxyType NOTIFY ProxyTypeChanged)
    Q_PROPERTY(bool isProxyTypeImmutable READ isProxyTypeImmutable CONSTANT)
    /**
      Get The type of proxy used by the application
    */
    static
    int proxyType()
    {
      return self()->mProxyType;
    }

    /**
      Is The type of proxy used by the application Immutable
    */
    static
    bool isProxyTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProxyType" ) );
    }

    /**
      Set IP or hostname of the proxy
    */
    static
    void setProxyHost( const QString & v )
    {
      if (v != self()->mProxyHost && !self()->isProxyHostImmutable()) {
        self()->mProxyHost = v;
        Q_EMIT self()->ProxyHostChanged();
      }
    }

    Q_PROPERTY(QString proxyHost READ proxyHost WRITE setProxyHost NOTIFY ProxyHostChanged)
    Q_PROPERTY(bool isProxyHostImmutable READ isProxyHostImmutable CONSTANT)
    Q_PROPERTY(QString defaultProxyHostValue READ defaultProxyHostValue CONSTANT)
    /**
      Get IP or hostname of the proxy
    */
    static
    QString proxyHost()
    {
      return self()->mProxyHost;
    }

    /**
      Is IP or hostname of the proxy Immutable
    */
    static
    bool isProxyHostImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProxyHost" ) );
    }

    /**
      Get IP or hostname of the proxy default value
    */
    static
    QString defaultProxyHostValue()
    {
        return defaultProxyHostValue_helper();
    }

    /**
      Set The port number of the proxy
    */
    static
    void setProxyPort( int v )
    {
      if (v != self()->mProxyPort && !self()->isProxyPortImmutable()) {
        self()->mProxyPort = v;
        Q_EMIT self()->ProxyPortChanged();
      }
    }

    Q_PROPERTY(int proxyPort READ proxyPort WRITE setProxyPort NOTIFY ProxyPortChanged)
    Q_PROPERTY(bool isProxyPortImmutable READ isProxyPortImmutable CONSTANT)
    Q_PROPERTY(int defaultProxyPortValue READ defaultProxyPortValue CONSTANT)
    /**
      Get The port number of the proxy
    */
    static
    int proxyPort()
    {
      return self()->mProxyPort;
    }

    /**
      Is The port number of the proxy Immutable
    */
    static
    bool isProxyPortImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProxyPort" ) );
    }

    /**
      Get The port number of the proxy default value
    */
    static
    int defaultProxyPortValue()
    {
        return defaultProxyPortValue_helper();
    }

    /**
      Set The user of the proxy
    */
    static
    void setProxyUser( const QString & v )
    {
      if (v != self()->mProxyUser && !self()->isProxyUserImmutable()) {
        self()->mProxyUser = v;
        Q_EMIT self()->ProxyUserChanged();
      }
    }

    Q_PROPERTY(QString proxyUser READ proxyUser WRITE setProxyUser NOTIFY ProxyUserChanged)
    Q_PROPERTY(bool isProxyUserImmutable READ isProxyUserImmutable CONSTANT)
    /**
      Get The user of the proxy
    */
    static
    QString proxyUser()
    {
      return self()->mProxyUser;
    }

    /**
      Is The user of the proxy Immutable
    */
    static
    bool isProxyUserImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProxyUser" ) );
    }

    /**
      Set The password of the proxy
    */
    static
    void setProxyPassword( const QString & v )
    {
      if (v != self()->mProxyPassword && !self()->isProxyPasswordImmutable()) {
        self()->mProxyPassword = v;
        Q_EMIT self()->ProxyPasswordChanged();
      }
    }

    Q_PROPERTY(QString proxyPassword READ proxyPassword WRITE setProxyPassword NOTIFY ProxyPasswordChanged)
    Q_PROPERTY(bool isProxyPasswordImmutable READ isProxyPasswordImmutable CONSTANT)
    /**
      Get The password of the proxy
    */
    static
    QString proxyPassword()
    {
      return self()->mProxyPassword;
    }

    /**
      Is The password of the proxy Immutable
    */
    static
    bool isProxyPasswordImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProxyPassword" ) );
    }


    enum {
      signalPrioritizeStreamingChanged = 1,
      signalContinuePlayingNextEntryChanged = 2,
      signalAdjustTimeLeftChanged = 3,
      signalRefreshOnStartupChanged = 4,
      signalDoFullUpdateChanged = 5,
      signalAutoQueueChanged = 6,
      signalAutoDownloadChanged = 7,
      signalAutoFeedUpdateIntervalChanged = 8,
      signalAutoDeleteOnPlayedChanged = 9,
      signalMarkAsPlayedBeforeEndChanged = 10,
      signalResetPositionOnPlayedChanged = 11,
      signalMarkUnreadOnNewFeedChanged = 12,
      signalMarkUnreadOnNewFeedCustomAmountChanged = 13,
      signalToggleRemainingTimeChanged = 14,
      signalArticleFontSizeChanged = 15,
      signalStoragePathChanged = 16,
      signalAlwaysShowFeedTitlesChanged = 17,
      signalShowEpisodeImageChanged = 18,
      signalShowPodcastTitleChanged = 19,
      signalShowTrayIconChanged = 20,
      signalTrayIconTypeChanged = 21,
      signalMinimizeToTrayChanged = 22,
      signalArticleFontUseSystemChanged = 23,
      signalInterfaceModeChanged = 24,
      signalMediabackendChanged = 25,
      signalPlaybackRatesChanged = 26,
      signalSkipForwardChanged = 27,
      signalSkipBackwardChanged = 28,
      signalMaximumParallelEpisodeDownloadsChanged = 29,
      signalCheckNetworkStatusChanged = 30,
      signalAllowMeteredFeedUpdatesChanged = 31,
      signalAllowMeteredEpisodeDownloadsChanged = 32,
      signalAllowMeteredImageDownloadsChanged = 33,
      signalAllowMeteredStreamingChanged = 34,
      signalSleepTimerValueChanged = 35,
      signalSleepTimerUnitsChanged = 36,
      signalSyncEnabledChanged = 37,
      signalSyncWhenUpdatingFeedsChanged = 38,
      signalSyncWhenPlayerstateChangesChanged = 39,
      signalSyncProviderChanged = 40,
      signalSyncHostnameChanged = 41,
      signalSyncUsernameChanged = 42,
      signalSyncDeviceChanged = 43,
      signalSyncDeviceNameChanged = 44,
      signalProxyTypeChanged = 45,
      signalProxyHostChanged = 46,
      signalProxyPortChanged = 47,
      signalProxyUserChanged = 48,
      signalProxyPasswordChanged = 49
    };

  Q_SIGNALS:
    void prioritizeStreamingChanged();

    void continuePlayingNextEntryChanged();

    void adjustTimeLeftChanged();

    void refreshOnStartupChanged();

    void doFullUpdateChanged();

    void autoQueueChanged();

    void autoDownloadChanged();

    void autoFeedUpdateIntervalChanged();

    void autoDeleteOnPlayedChanged();

    void markAsPlayedBeforeEndChanged();

    void resetPositionOnPlayedChanged();

    void markUnreadOnNewFeedChanged();

    void markUnreadOnNewFeedCustomAmountChanged();

    void toggleRemainingTimeChanged();

    void articleFontSizeChanged();

    void StoragePathChanged();

    void alwaysShowFeedTitlesChanged();

    void showEpisodeImageChanged();

    void showPodcastTitleChanged();

    void showTrayIconChanged();

    void trayIconTypeChanged();

    void minimizeToTrayChanged();

    void articleFontUseSystemChanged();

    void interfaceModeChanged();

    void mediabackendChanged();

    void playbackRatesChanged();

    void skipForwardChanged();

    void skipBackwardChanged();

    void maximumParallelEpisodeDownloadsChanged();

    void checkNetworkStatusChanged();

    void allowMeteredFeedUpdatesChanged();

    void allowMeteredEpisodeDownloadsChanged();

    void allowMeteredImageDownloadsChanged();

    void allowMeteredStreamingChanged();

    void sleepTimerValueChanged();

    void sleepTimerUnitsChanged();

    void syncEnabledChanged();

    void syncWhenUpdatingFeedsChanged();

    void syncWhenPlayerstateChangesChanged();

    void syncProviderChanged();

    void syncHostnameChanged();

    void syncUsernameChanged();

    void syncDeviceChanged();

    void syncDeviceNameChanged();

    void ProxyTypeChanged();

    void ProxyHostChanged();

    void ProxyPortChanged();

    void ProxyUserChanged();

    void ProxyPasswordChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    SettingsManager(QObject *parent = nullptr);
    friend class SettingsManagerHelper;


    // General
    bool mPrioritizeStreaming;
    static bool defaultPrioritizeStreamingValue_helper();
    bool mContinuePlayingNextEntry;
    static bool defaultContinuePlayingNextEntryValue_helper();
    bool mAdjustTimeLeft;
    static bool defaultAdjustTimeLeftValue_helper();
    bool mRefreshOnStartup;
    static bool defaultRefreshOnStartupValue_helper();
    bool mDoFullUpdate;
    static bool defaultDoFullUpdateValue_helper();
    bool mAutoQueue;
    static bool defaultAutoQueueValue_helper();
    bool mAutoDownload;
    static bool defaultAutoDownloadValue_helper();
    int mAutoFeedUpdateInterval;
    static int defaultAutoFeedUpdateIntervalValue_helper();
    int mAutoDeleteOnPlayed;
    static int defaultAutoDeleteOnPlayedValue_helper();
    int mMarkAsPlayedBeforeEnd;
    static int defaultMarkAsPlayedBeforeEndValue_helper();
    bool mResetPositionOnPlayed;
    static bool defaultResetPositionOnPlayedValue_helper();
    int mMarkUnreadOnNewFeed;
    static int defaultMarkUnreadOnNewFeedValue_helper();
    int mMarkUnreadOnNewFeedCustomAmount;
    static int defaultMarkUnreadOnNewFeedCustomAmountValue_helper();
    bool mToggleRemainingTime;
    static bool defaultToggleRemainingTimeValue_helper();
    int mArticleFontSize;
    static int defaultArticleFontSizeValue_helper();
    QUrl mStoragePath;
    static QUrl defaultStoragePathValue_helper();

    // Appearance
    bool mAlwaysShowFeedTitles;
    static bool defaultAlwaysShowFeedTitlesValue_helper();
    bool mShowEpisodeImage;
    static bool defaultShowEpisodeImageValue_helper();
    bool mShowPodcastTitle;
    static bool defaultShowPodcastTitleValue_helper();
    bool mShowTrayIcon;
    static bool defaultShowTrayIconValue_helper();
    int mTrayIconType;
    static int defaultTrayIconTypeValue_helper();
    bool mMinimizeToTray;
    static bool defaultMinimizeToTrayValue_helper();
    bool mArticleFontUseSystem;
    static bool defaultArticleFontUseSystemValue_helper();
    int mInterfaceMode;
    static int defaultInterfaceModeValue_helper();

    // Playback Settings
    int mMediabackend;
    static int defaultMediabackendValue_helper();
    QList<int> mPlaybackRates;
    static QList<int> defaultPlaybackRatesValue_helper();
    uint mSkipForward;
    static uint defaultSkipForwardValue_helper();
    uint mSkipBackward;
    static uint defaultSkipBackwardValue_helper();

    // Network
    int mMaximumParallelEpisodeDownloads;
    static int defaultMaximumParallelEpisodeDownloadsValue_helper();
    bool mCheckNetworkStatus;
    static bool defaultCheckNetworkStatusValue_helper();
    bool mAllowMeteredFeedUpdates;
    static bool defaultAllowMeteredFeedUpdatesValue_helper();
    bool mAllowMeteredEpisodeDownloads;
    static bool defaultAllowMeteredEpisodeDownloadsValue_helper();
    bool mAllowMeteredImageDownloads;
    static bool defaultAllowMeteredImageDownloadsValue_helper();
    bool mAllowMeteredStreaming;
    static bool defaultAllowMeteredStreamingValue_helper();

    // Persistency
    int mSleepTimerValue;
    static int defaultSleepTimerValueValue_helper();
    int mSleepTimerUnits;
    static int defaultSleepTimerUnitsValue_helper();

    // Synchronization
    bool mSyncEnabled;
    static bool defaultSyncEnabledValue_helper();
    bool mSyncWhenUpdatingFeeds;
    static bool defaultSyncWhenUpdatingFeedsValue_helper();
    bool mSyncWhenPlayerstateChanges;
    static bool defaultSyncWhenPlayerstateChangesValue_helper();
    int mSyncProvider;
    static int defaultSyncProviderValue_helper();
    QString mSyncHostname;
    static QString defaultSyncHostnameValue_helper();
    QString mSyncUsername;
    static QString defaultSyncUsernameValue_helper();
    QString mSyncDevice;
    static QString defaultSyncDeviceValue_helper();
    QString mSyncDeviceName;
    static QString defaultSyncDeviceNameValue_helper();

    // NetworkProxy
    int mProxyType;
    static int defaultProxyTypeValue_helper();
    QString mProxyHost;
    static QString defaultProxyHostValue_helper();
    int mProxyPort;
    static int defaultProxyPortValue_helper();
    QString mProxyUser;
    static QString defaultProxyUserValue_helper();
    QString mProxyPassword;
    static QString defaultProxyPasswordValue_helper();
};

#endif

