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

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

#include <QString>
#include <QDir>
#include <QUrl>
#include <KIconLoader>
#include <smb4kcore_export.h>

class SMB4KCORE_EXPORT Smb4KSettings : public KConfigSkeleton
{
  public:
    class EnumMainWindowTabOrientation
    {
      public:
      enum type { Top, Bottom, Left, Right, COUNT };
    };
    class EnumSharesViewMode
    {
      public:
      enum type { IconView, ListView, COUNT };
    };
    class EnumMinimalClientProtocolVersion
    {
      public:
      enum type { NT1, SMB2, SMB3, COUNT };
    };
    class EnumMaximalClientProtocolVersion
    {
      public:
      enum type { NT1, SMB2, SMB3, COUNT };
    };
    class EnumEncryptionLevel
    {
      public:
      enum type { None, Request, Require, COUNT };
    };

    static Smb4KSettings *self();
    ~Smb4KSettings() override;

    /**
      Set Tab orientation:
    */
    static
    void setMainWindowTabOrientation( int v )
    {
      if (!self()->isMainWindowTabOrientationImmutable())
        self()->mMainWindowTabOrientation = v;
    }

    /**
      Get Tab orientation:
    */
    static
    int mainWindowTabOrientation()
    {
      return self()->mMainWindowTabOrientation;
    }

    /**
      Is Tab orientation: Immutable
    */
    static
    bool isMainWindowTabOrientationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MainWindowTabOrientation" ) );
    }

    /**
      Get Item object corresponding to MainWindowTabOrientation()
    */
    ItemEnum *mainWindowTabOrientationItem()
    {
      return mMainWindowTabOrientationItem;
    }

    /**
      Set Show custom bookmark label if available
    */
    static
    void setShowCustomBookmarkLabel( bool v )
    {
      if (!self()->isShowCustomBookmarkLabelImmutable())
        self()->mShowCustomBookmarkLabel = v;
    }

    /**
      Get Show custom bookmark label if available
    */
    static
    bool showCustomBookmarkLabel()
    {
      return self()->mShowCustomBookmarkLabel;
    }

    /**
      Is Show custom bookmark label if available Immutable
    */
    static
    bool isShowCustomBookmarkLabelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowCustomBookmarkLabel" ) );
    }

    /**
      Get Item object corresponding to ShowCustomBookmarkLabel()
    */
    ItemBool *showCustomBookmarkLabelItem()
    {
      return mShowCustomBookmarkLabelItem;
    }

    /**
      Set Start docked
    */
    static
    void setStartMainWindowDocked( bool v )
    {
      if (!self()->isStartMainWindowDockedImmutable())
        self()->mStartMainWindowDocked = v;
    }

    /**
      Get Start docked
    */
    static
    bool startMainWindowDocked()
    {
      return self()->mStartMainWindowDocked;
    }

    /**
      Is Start docked Immutable
    */
    static
    bool isStartMainWindowDockedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartMainWindowDocked" ) );
    }

    /**
      Get Item object corresponding to StartMainWindowDocked()
    */
    ItemBool *startMainWindowDockedItem()
    {
      return mStartMainWindowDockedItem;
    }

    /**
      Set Show the type of the share
    */
    static
    void setShowType( bool v )
    {
      if (!self()->isShowTypeImmutable())
        self()->mShowType = v;
    }

    /**
      Get Show the type of the share
    */
    static
    bool showType()
    {
      return self()->mShowType;
    }

    /**
      Is Show the type of the share Immutable
    */
    static
    bool isShowTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowType" ) );
    }

    /**
      Get Item object corresponding to ShowType()
    */
    ItemBool *showTypeItem()
    {
      return mShowTypeItem;
    }

    /**
      Set Show the IP address of the server
    */
    static
    void setShowIPAddress( bool v )
    {
      if (!self()->isShowIPAddressImmutable())
        self()->mShowIPAddress = v;
    }

    /**
      Get Show the IP address of the server
    */
    static
    bool showIPAddress()
    {
      return self()->mShowIPAddress;
    }

    /**
      Is Show the IP address of the server Immutable
    */
    static
    bool isShowIPAddressImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowIPAddress" ) );
    }

    /**
      Get Item object corresponding to ShowIPAddress()
    */
    ItemBool *showIPAddressItem()
    {
      return mShowIPAddressItem;
    }

    /**
      Set Show the comment
    */
    static
    void setShowComment( bool v )
    {
      if (!self()->isShowCommentImmutable())
        self()->mShowComment = v;
    }

    /**
      Get Show the comment
    */
    static
    bool showComment()
    {
      return self()->mShowComment;
    }

    /**
      Is Show the comment Immutable
    */
    static
    bool isShowCommentImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowComment" ) );
    }

    /**
      Get Item object corresponding to ShowComment()
    */
    ItemBool *showCommentItem()
    {
      return mShowCommentItem;
    }

    /**
      Set Show tooltips for network items
    */
    static
    void setShowNetworkItemToolTip( bool v )
    {
      if (!self()->isShowNetworkItemToolTipImmutable())
        self()->mShowNetworkItemToolTip = v;
    }

    /**
      Get Show tooltips for network items
    */
    static
    bool showNetworkItemToolTip()
    {
      return self()->mShowNetworkItemToolTip;
    }

    /**
      Is Show tooltips for network items Immutable
    */
    static
    bool isShowNetworkItemToolTipImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowNetworkItemToolTip" ) );
    }

    /**
      Get Item object corresponding to ShowNetworkItemToolTip()
    */
    ItemBool *showNetworkItemToolTipItem()
    {
      return mShowNetworkItemToolTipItem;
    }

    /**
      Set Automatically expand domains and hosts
    */
    static
    void setAutoExpandNetworkItems( bool v )
    {
      if (!self()->isAutoExpandNetworkItemsImmutable())
        self()->mAutoExpandNetworkItems = v;
    }

    /**
      Get Automatically expand domains and hosts
    */
    static
    bool autoExpandNetworkItems()
    {
      return self()->mAutoExpandNetworkItems;
    }

    /**
      Is Automatically expand domains and hosts Immutable
    */
    static
    bool isAutoExpandNetworkItemsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoExpandNetworkItems" ) );
    }

    /**
      Get Item object corresponding to AutoExpandNetworkItems()
    */
    ItemBool *autoExpandNetworkItemsItem()
    {
      return mAutoExpandNetworkItemsItem;
    }

    /**
      Set Show tooltips for mounted shares
    */
    static
    void setShowShareToolTip( bool v )
    {
      if (!self()->isShowShareToolTipImmutable())
        self()->mShowShareToolTip = v;
    }

    /**
      Get Show tooltips for mounted shares
    */
    static
    bool showShareToolTip()
    {
      return self()->mShowShareToolTip;
    }

    /**
      Is Show tooltips for mounted shares Immutable
    */
    static
    bool isShowShareToolTipImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowShareToolTip" ) );
    }

    /**
      Get Item object corresponding to ShowShareToolTip()
    */
    ItemBool *showShareToolTipItem()
    {
      return mShowShareToolTipItem;
    }

    /**
      Set View mode:
    */
    static
    void setSharesViewMode( int v )
    {
      if (!self()->isSharesViewModeImmutable())
        self()->mSharesViewMode = v;
    }

    /**
      Get View mode:
    */
    static
    int sharesViewMode()
    {
      return self()->mSharesViewMode;
    }

    /**
      Is View mode: Immutable
    */
    static
    bool isSharesViewModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SharesViewMode" ) );
    }

    /**
      Get Item object corresponding to SharesViewMode()
    */
    ItemEnum *sharesViewModeItem()
    {
      return mSharesViewModeItem;
    }

    /**
      Set Icon size for the icon view:
    */
    static
    void setSharesViewIconSizeIconView( int v )
    {
      if (v < KIconLoader::SizeSmall)
      {
        qDebug() << "setSharesViewIconSizeIconView: value " << v << " is less than the minimum value of KIconLoader::SizeSmall";
        v = KIconLoader::SizeSmall;
      }

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

      if (!self()->isSharesViewIconSizeIconViewImmutable())
        self()->mSharesViewIconSizeIconView = v;
    }

    /**
      Get Icon size for the icon view:
    */
    static
    int sharesViewIconSizeIconView()
    {
      return self()->mSharesViewIconSizeIconView;
    }

    /**
      Is Icon size for the icon view: Immutable
    */
    static
    bool isSharesViewIconSizeIconViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SharesViewIconSizeIconView" ) );
    }

    /**
      Get Item object corresponding to SharesViewIconSizeIconView()
    */
    ItemInt *sharesViewIconSizeIconViewItem()
    {
      return mSharesViewIconSizeIconViewItem;
    }

    /**
      Set Icon size for the list view:
    */
    static
    void setSharesViewIconSizeListView( int v )
    {
      if (v < KIconLoader::SizeSmall)
      {
        qDebug() << "setSharesViewIconSizeListView: value " << v << " is less than the minimum value of KIconLoader::SizeSmall";
        v = KIconLoader::SizeSmall;
      }

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

      if (!self()->isSharesViewIconSizeListViewImmutable())
        self()->mSharesViewIconSizeListView = v;
    }

    /**
      Get Icon size for the list view:
    */
    static
    int sharesViewIconSizeListView()
    {
      return self()->mSharesViewIconSizeListView;
    }

    /**
      Is Icon size for the list view: Immutable
    */
    static
    bool isSharesViewIconSizeListViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SharesViewIconSizeListView" ) );
    }

    /**
      Get Item object corresponding to SharesViewIconSizeListView()
    */
    ItemInt *sharesViewIconSizeListViewItem()
    {
      return mSharesViewIconSizeListViewItem;
    }

    /**
      Set Icon size:
    */
    static
    void setNetworkBrowserIconSize( int v )
    {
      if (v < KIconLoader::SizeSmall)
      {
        qDebug() << "setNetworkBrowserIconSize: value " << v << " is less than the minimum value of KIconLoader::SizeSmall";
        v = KIconLoader::SizeSmall;
      }

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

      if (!self()->isNetworkBrowserIconSizeImmutable())
        self()->mNetworkBrowserIconSize = v;
    }

    /**
      Get Icon size:
    */
    static
    int networkBrowserIconSize()
    {
      return self()->mNetworkBrowserIconSize;
    }

    /**
      Is Icon size: Immutable
    */
    static
    bool isNetworkBrowserIconSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "NetworkBrowserIconSize" ) );
    }

    /**
      Get Item object corresponding to NetworkBrowserIconSize()
    */
    ItemInt *networkBrowserIconSizeItem()
    {
      return mNetworkBrowserIconSizeItem;
    }

    /**
      Set Use Web Services Dynamic Discovery (WS-Discovery) for browsing
    */
    static
    void setUseWsDiscovery( bool v )
    {
      if (!self()->isUseWsDiscoveryImmutable())
        self()->mUseWsDiscovery = v;
    }

    /**
      Get Use Web Services Dynamic Discovery (WS-Discovery) for browsing
    */
    static
    bool useWsDiscovery()
    {
      return self()->mUseWsDiscovery;
    }

    /**
      Is Use Web Services Dynamic Discovery (WS-Discovery) for browsing Immutable
    */
    static
    bool isUseWsDiscoveryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseWsDiscovery" ) );
    }

    /**
      Get Item object corresponding to UseWsDiscovery()
    */
    ItemBool *useWsDiscoveryItem()
    {
      return mUseWsDiscoveryItem;
    }

    /**
      Set Use DNS Service Discovery (DNS-SD) for browsing
    */
    static
    void setUseDnsServiceDiscovery( bool v )
    {
      if (!self()->isUseDnsServiceDiscoveryImmutable())
        self()->mUseDnsServiceDiscovery = v;
    }

    /**
      Get Use DNS Service Discovery (DNS-SD) for browsing
    */
    static
    bool useDnsServiceDiscovery()
    {
      return self()->mUseDnsServiceDiscovery;
    }

    /**
      Is Use DNS Service Discovery (DNS-SD) for browsing Immutable
    */
    static
    bool isUseDnsServiceDiscoveryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseDnsServiceDiscovery" ) );
    }

    /**
      Get Item object corresponding to UseDnsServiceDiscovery()
    */
    ItemBool *useDnsServiceDiscoveryItem()
    {
      return mUseDnsServiceDiscoveryItem;
    }

    /**
      Set Set minimal and maximal SMB protocol version
    */
    static
    void setUseClientProtocolVersions( bool v )
    {
      if (!self()->isUseClientProtocolVersionsImmutable())
        self()->mUseClientProtocolVersions = v;
    }

    /**
      Get Set minimal and maximal SMB protocol version
    */
    static
    bool useClientProtocolVersions()
    {
      return self()->mUseClientProtocolVersions;
    }

    /**
      Is Set minimal and maximal SMB protocol version Immutable
    */
    static
    bool isUseClientProtocolVersionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseClientProtocolVersions" ) );
    }

    /**
      Get Item object corresponding to UseClientProtocolVersions()
    */
    ItemBool *useClientProtocolVersionsItem()
    {
      return mUseClientProtocolVersionsItem;
    }

    /**
      Set Minimal SMB protocol version:
    */
    static
    void setMinimalClientProtocolVersion( int v )
    {
      if (!self()->isMinimalClientProtocolVersionImmutable())
        self()->mMinimalClientProtocolVersion = v;
    }

    /**
      Get Minimal SMB protocol version:
    */
    static
    int minimalClientProtocolVersion()
    {
      return self()->mMinimalClientProtocolVersion;
    }

    /**
      Is Minimal SMB protocol version: Immutable
    */
    static
    bool isMinimalClientProtocolVersionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MinimalClientProtocolVersion" ) );
    }

    /**
      Get Item object corresponding to MinimalClientProtocolVersion()
    */
    ItemEnum *minimalClientProtocolVersionItem()
    {
      return mMinimalClientProtocolVersionItem;
    }

    /**
      Set Maximal SMB protocol version:
    */
    static
    void setMaximalClientProtocolVersion( int v )
    {
      if (!self()->isMaximalClientProtocolVersionImmutable())
        self()->mMaximalClientProtocolVersion = v;
    }

    /**
      Get Maximal SMB protocol version:
    */
    static
    int maximalClientProtocolVersion()
    {
      return self()->mMaximalClientProtocolVersion;
    }

    /**
      Is Maximal SMB protocol version: Immutable
    */
    static
    bool isMaximalClientProtocolVersionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaximalClientProtocolVersion" ) );
    }

    /**
      Get Item object corresponding to MaximalClientProtocolVersion()
    */
    ItemEnum *maximalClientProtocolVersionItem()
    {
      return mMaximalClientProtocolVersionItem;
    }

    /**
      Set Set the SMB port to:
    */
    static
    void setUseRemoteSmbPort( bool v )
    {
      if (!self()->isUseRemoteSmbPortImmutable())
        self()->mUseRemoteSmbPort = v;
    }

    /**
      Get Set the SMB port to:
    */
    static
    bool useRemoteSmbPort()
    {
      return self()->mUseRemoteSmbPort;
    }

    /**
      Is Set the SMB port to: Immutable
    */
    static
    bool isUseRemoteSmbPortImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseRemoteSmbPort" ) );
    }

    /**
      Get Item object corresponding to UseRemoteSmbPort()
    */
    ItemBool *useRemoteSmbPortItem()
    {
      return mUseRemoteSmbPortItem;
    }

    /**
      Set RemoteSmbPort
    */
    static
    void setRemoteSmbPort( int v )
    {
      if (v < 1)
      {
        qDebug() << "setRemoteSmbPort: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

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

      if (!self()->isRemoteSmbPortImmutable())
        self()->mRemoteSmbPort = v;
    }

    /**
      Get RemoteSmbPort
    */
    static
    int remoteSmbPort()
    {
      return self()->mRemoteSmbPort;
    }

    /**
      Is RemoteSmbPort Immutable
    */
    static
    bool isRemoteSmbPortImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RemoteSmbPort" ) );
    }

    /**
      Get Item object corresponding to RemoteSmbPort()
    */
    ItemInt *remoteSmbPortItem()
    {
      return mRemoteSmbPortItem;
    }

    /**
      Set This computer is on a large network neighborhood
    */
    static
    void setLargeNetworkNeighborhood( bool v )
    {
      if (!self()->isLargeNetworkNeighborhoodImmutable())
        self()->mLargeNetworkNeighborhood = v;
    }

    /**
      Get This computer is on a large network neighborhood
    */
    static
    bool largeNetworkNeighborhood()
    {
      return self()->mLargeNetworkNeighborhood;
    }

    /**
      Is This computer is on a large network neighborhood Immutable
    */
    static
    bool isLargeNetworkNeighborhoodImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LargeNetworkNeighborhood" ) );
    }

    /**
      Get Item object corresponding to LargeNetworkNeighborhood()
    */
    ItemBool *largeNetworkNeighborhoodItem()
    {
      return mLargeNetworkNeighborhoodItem;
    }

    /**
      Set Master browsers require authentication
    */
    static
    void setMasterBrowsersRequireAuth( bool v )
    {
      if (!self()->isMasterBrowsersRequireAuthImmutable())
        self()->mMasterBrowsersRequireAuth = v;
    }

    /**
      Get Master browsers require authentication
    */
    static
    bool masterBrowsersRequireAuth()
    {
      return self()->mMasterBrowsersRequireAuth;
    }

    /**
      Is Master browsers require authentication Immutable
    */
    static
    bool isMasterBrowsersRequireAuthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MasterBrowsersRequireAuth" ) );
    }

    /**
      Get Item object corresponding to MasterBrowsersRequireAuth()
    */
    ItemBool *masterBrowsersRequireAuthItem()
    {
      return mMasterBrowsersRequireAuthItem;
    }

    /**
      Set Use Kerberos for authentication
    */
    static
    void setUseKerberos( bool v )
    {
      if (!self()->isUseKerberosImmutable())
        self()->mUseKerberos = v;
    }

    /**
      Get Use Kerberos for authentication
    */
    static
    bool useKerberos()
    {
      return self()->mUseKerberos;
    }

    /**
      Is Use Kerberos for authentication Immutable
    */
    static
    bool isUseKerberosImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseKerberos" ) );
    }

    /**
      Get Item object corresponding to UseKerberos()
    */
    ItemBool *useKerberosItem()
    {
      return mUseKerberosItem;
    }

    /**
      Set Use Winbind ccache for authentication
    */
    static
    void setUseWinbindCCache( bool v )
    {
      if (!self()->isUseWinbindCCacheImmutable())
        self()->mUseWinbindCCache = v;
    }

    /**
      Get Use Winbind ccache for authentication
    */
    static
    bool useWinbindCCache()
    {
      return self()->mUseWinbindCCache;
    }

    /**
      Is Use Winbind ccache for authentication Immutable
    */
    static
    bool isUseWinbindCCacheImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseWinbindCCache" ) );
    }

    /**
      Get Item object corresponding to UseWinbindCCache()
    */
    ItemBool *useWinbindCCacheItem()
    {
      return mUseWinbindCCacheItem;
    }

    /**
      Set Set the encryption level to:
    */
    static
    void setUseEncryptionLevel( bool v )
    {
      if (!self()->isUseEncryptionLevelImmutable())
        self()->mUseEncryptionLevel = v;
    }

    /**
      Get Set the encryption level to:
    */
    static
    bool useEncryptionLevel()
    {
      return self()->mUseEncryptionLevel;
    }

    /**
      Is Set the encryption level to: Immutable
    */
    static
    bool isUseEncryptionLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseEncryptionLevel" ) );
    }

    /**
      Get Item object corresponding to UseEncryptionLevel()
    */
    ItemBool *useEncryptionLevelItem()
    {
      return mUseEncryptionLevelItem;
    }

    /**
      Set EncryptionLevel
    */
    static
    void setEncryptionLevel( int v )
    {
      if (!self()->isEncryptionLevelImmutable())
        self()->mEncryptionLevel = v;
    }

    /**
      Get EncryptionLevel
    */
    static
    int encryptionLevel()
    {
      return self()->mEncryptionLevel;
    }

    /**
      Is EncryptionLevel Immutable
    */
    static
    bool isEncryptionLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EncryptionLevel" ) );
    }

    /**
      Get Item object corresponding to EncryptionLevel()
    */
    ItemEnum *encryptionLevelItem()
    {
      return mEncryptionLevelItem;
    }

    /**
      Set Preview hidden files and directories
    */
    static
    void setPreviewHiddenItems( bool v )
    {
      if (!self()->isPreviewHiddenItemsImmutable())
        self()->mPreviewHiddenItems = v;
    }

    /**
      Get Preview hidden files and directories
    */
    static
    bool previewHiddenItems()
    {
      return self()->mPreviewHiddenItems;
    }

    /**
      Is Preview hidden files and directories Immutable
    */
    static
    bool isPreviewHiddenItemsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreviewHiddenItems" ) );
    }

    /**
      Get Item object corresponding to PreviewHiddenItems()
    */
    ItemBool *previewHiddenItemsItem()
    {
      return mPreviewHiddenItemsItem;
    }

    /**
      Set Detect printer shares
    */
    static
    void setDetectPrinterShares( bool v )
    {
      if (!self()->isDetectPrinterSharesImmutable())
        self()->mDetectPrinterShares = v;
    }

    /**
      Get Detect printer shares
    */
    static
    bool detectPrinterShares()
    {
      return self()->mDetectPrinterShares;
    }

    /**
      Is Detect printer shares Immutable
    */
    static
    bool isDetectPrinterSharesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DetectPrinterShares" ) );
    }

    /**
      Get Item object corresponding to DetectPrinterShares()
    */
    ItemBool *detectPrinterSharesItem()
    {
      return mDetectPrinterSharesItem;
    }

    /**
      Set Detect hidden shares
    */
    static
    void setDetectHiddenShares( bool v )
    {
      if (!self()->isDetectHiddenSharesImmutable())
        self()->mDetectHiddenShares = v;
    }

    /**
      Get Detect hidden shares
    */
    static
    bool detectHiddenShares()
    {
      return self()->mDetectHiddenShares;
    }

    /**
      Is Detect hidden shares Immutable
    */
    static
    bool isDetectHiddenSharesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DetectHiddenShares" ) );
    }

    /**
      Get Item object corresponding to DetectHiddenShares()
    */
    ItemBool *detectHiddenSharesItem()
    {
      return mDetectHiddenSharesItem;
    }

    /**
      Set Enable Wake-On-LAN features
    */
    static
    void setEnableWakeOnLAN( bool v )
    {
      if (!self()->isEnableWakeOnLANImmutable())
        self()->mEnableWakeOnLAN = v;
    }

    /**
      Get Enable Wake-On-LAN features
    */
    static
    bool enableWakeOnLAN()
    {
      return self()->mEnableWakeOnLAN;
    }

    /**
      Is Enable Wake-On-LAN features Immutable
    */
    static
    bool isEnableWakeOnLANImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EnableWakeOnLAN" ) );
    }

    /**
      Get Item object corresponding to EnableWakeOnLAN()
    */
    ItemBool *enableWakeOnLANItem()
    {
      return mEnableWakeOnLANItem;
    }

    /**
      Set Waiting time:
    */
    static
    void setWakeOnLANWaitingTime( int v )
    {
      if (v < 0)
      {
        qDebug() << "setWakeOnLANWaitingTime: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isWakeOnLANWaitingTimeImmutable())
        self()->mWakeOnLANWaitingTime = v;
    }

    /**
      Get Waiting time:
    */
    static
    int wakeOnLANWaitingTime()
    {
      return self()->mWakeOnLANWaitingTime;
    }

    /**
      Is Waiting time: Immutable
    */
    static
    bool isWakeOnLANWaitingTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WakeOnLANWaitingTime" ) );
    }

    /**
      Get Item object corresponding to WakeOnLANWaitingTime()
    */
    ItemInt *wakeOnLANWaitingTimeItem()
    {
      return mWakeOnLANWaitingTimeItem;
    }

    /**
      Set Synchronization prefix:
    */
    static
    void setRsyncPrefix( const QUrl & v )
    {
      if (!self()->isRsyncPrefixImmutable())
        self()->mRsyncPrefix = v;
    }

    /**
      Get Synchronization prefix:
    */
    static
    QUrl rsyncPrefix()
    {
      return self()->mRsyncPrefix;
    }

    /**
      Is Synchronization prefix: Immutable
    */
    static
    bool isRsyncPrefixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RsyncPrefix" ) );
    }

    /**
      Get Item object corresponding to RsyncPrefix()
    */
    ItemUrl *rsyncPrefixItem()
    {
      return mRsyncPrefixItem;
    }

    /**
      Set Archive mode
    */
    static
    void setArchiveMode( bool v )
    {
      if (!self()->isArchiveModeImmutable())
        self()->mArchiveMode = v;
    }

    /**
      Get Archive mode
    */
    static
    bool archiveMode()
    {
      return self()->mArchiveMode;
    }

    /**
      Is Archive mode Immutable
    */
    static
    bool isArchiveModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ArchiveMode" ) );
    }

    /**
      Get Item object corresponding to ArchiveMode()
    */
    ItemBool *archiveModeItem()
    {
      return mArchiveModeItem;
    }

    /**
      Set Recurse into subdirectories
    */
    static
    void setRecurseIntoDirectories( bool v )
    {
      if (!self()->isRecurseIntoDirectoriesImmutable())
        self()->mRecurseIntoDirectories = v;
    }

    /**
      Get Recurse into subdirectories
    */
    static
    bool recurseIntoDirectories()
    {
      return self()->mRecurseIntoDirectories;
    }

    /**
      Is Recurse into subdirectories Immutable
    */
    static
    bool isRecurseIntoDirectoriesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RecurseIntoDirectories" ) );
    }

    /**
      Get Item object corresponding to RecurseIntoDirectories()
    */
    ItemBool *recurseIntoDirectoriesItem()
    {
      return mRecurseIntoDirectoriesItem;
    }

    /**
      Set Update files
    */
    static
    void setUpdateTarget( bool v )
    {
      if (!self()->isUpdateTargetImmutable())
        self()->mUpdateTarget = v;
    }

    /**
      Get Update files
    */
    static
    bool updateTarget()
    {
      return self()->mUpdateTarget;
    }

    /**
      Is Update files Immutable
    */
    static
    bool isUpdateTargetImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UpdateTarget" ) );
    }

    /**
      Get Item object corresponding to UpdateTarget()
    */
    ItemBool *updateTargetItem()
    {
      return mUpdateTargetItem;
    }

    /**
      Set Update files in place
    */
    static
    void setUpdateInPlace( bool v )
    {
      if (!self()->isUpdateInPlaceImmutable())
        self()->mUpdateInPlace = v;
    }

    /**
      Get Update files in place
    */
    static
    bool updateInPlace()
    {
      return self()->mUpdateInPlace;
    }

    /**
      Is Update files in place Immutable
    */
    static
    bool isUpdateInPlaceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UpdateInPlace" ) );
    }

    /**
      Get Item object corresponding to UpdateInPlace()
    */
    ItemBool *updateInPlaceItem()
    {
      return mUpdateInPlaceItem;
    }

    /**
      Set Use relative path names
    */
    static
    void setRelativePathNames( bool v )
    {
      if (!self()->isRelativePathNamesImmutable())
        self()->mRelativePathNames = v;
    }

    /**
      Get Use relative path names
    */
    static
    bool relativePathNames()
    {
      return self()->mRelativePathNames;
    }

    /**
      Is Use relative path names Immutable
    */
    static
    bool isRelativePathNamesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RelativePathNames" ) );
    }

    /**
      Get Item object corresponding to RelativePathNames()
    */
    ItemBool *relativePathNamesItem()
    {
      return mRelativePathNamesItem;
    }

    /**
      Set Do not send implied directories
    */
    static
    void setNoImpliedDirectories( bool v )
    {
      if (!self()->isNoImpliedDirectoriesImmutable())
        self()->mNoImpliedDirectories = v;
    }

    /**
      Get Do not send implied directories
    */
    static
    bool noImpliedDirectories()
    {
      return self()->mNoImpliedDirectories;
    }

    /**
      Is Do not send implied directories Immutable
    */
    static
    bool isNoImpliedDirectoriesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "NoImpliedDirectories" ) );
    }

    /**
      Get Item object corresponding to NoImpliedDirectories()
    */
    ItemBool *noImpliedDirectoriesItem()
    {
      return mNoImpliedDirectoriesItem;
    }

    /**
      Set Transfer directories without recursing
    */
    static
    void setTransferDirectories( bool v )
    {
      if (!self()->isTransferDirectoriesImmutable())
        self()->mTransferDirectories = v;
    }

    /**
      Get Transfer directories without recursing
    */
    static
    bool transferDirectories()
    {
      return self()->mTransferDirectories;
    }

    /**
      Is Transfer directories without recursing Immutable
    */
    static
    bool isTransferDirectoriesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TransferDirectories" ) );
    }

    /**
      Get Item object corresponding to TransferDirectories()
    */
    ItemBool *transferDirectoriesItem()
    {
      return mTransferDirectoriesItem;
    }

    /**
      Set Compress data during transfer
    */
    static
    void setCompressData( bool v )
    {
      if (!self()->isCompressDataImmutable())
        self()->mCompressData = v;
    }

    /**
      Get Compress data during transfer
    */
    static
    bool compressData()
    {
      return self()->mCompressData;
    }

    /**
      Is Compress data during transfer Immutable
    */
    static
    bool isCompressDataImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CompressData" ) );
    }

    /**
      Get Item object corresponding to CompressData()
    */
    ItemBool *compressDataItem()
    {
      return mCompressDataItem;
    }

    /**
      Set Set compression level:
    */
    static
    void setUseCompressionLevel( bool v )
    {
      if (!self()->isUseCompressionLevelImmutable())
        self()->mUseCompressionLevel = v;
    }

    /**
      Get Set compression level:
    */
    static
    bool useCompressionLevel()
    {
      return self()->mUseCompressionLevel;
    }

    /**
      Is Set compression level: Immutable
    */
    static
    bool isUseCompressionLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseCompressionLevel" ) );
    }

    /**
      Get Item object corresponding to UseCompressionLevel()
    */
    ItemBool *useCompressionLevelItem()
    {
      return mUseCompressionLevelItem;
    }

    /**
      Set The value for the UseCompressionLevel config entry
    */
    static
    void setCompressionLevel( int v )
    {
      if (v < 0)
      {
        qDebug() << "setCompressionLevel: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isCompressionLevelImmutable())
        self()->mCompressionLevel = v;
    }

    /**
      Get The value for the UseCompressionLevel config entry
    */
    static
    int compressionLevel()
    {
      return self()->mCompressionLevel;
    }

    /**
      Is The value for the UseCompressionLevel config entry Immutable
    */
    static
    bool isCompressionLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CompressionLevel" ) );
    }

    /**
      Get Item object corresponding to CompressionLevel()
    */
    ItemInt *compressionLevelItem()
    {
      return mCompressionLevelItem;
    }

    /**
      Set Skip compression for following file suffixes:
    */
    static
    void setUseSkipCompression( bool v )
    {
      if (!self()->isUseSkipCompressionImmutable())
        self()->mUseSkipCompression = v;
    }

    /**
      Get Skip compression for following file suffixes:
    */
    static
    bool useSkipCompression()
    {
      return self()->mUseSkipCompression;
    }

    /**
      Is Skip compression for following file suffixes: Immutable
    */
    static
    bool isUseSkipCompressionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseSkipCompression" ) );
    }

    /**
      Get Item object corresponding to UseSkipCompression()
    */
    ItemBool *useSkipCompressionItem()
    {
      return mUseSkipCompressionItem;
    }

    /**
      Set The value(s) for the UseSkipCompression config entry
    */
    static
    void setSkipCompression( const QString & v )
    {
      if (!self()->isSkipCompressionImmutable())
        self()->mSkipCompression = v;
    }

    /**
      Get The value(s) for the UseSkipCompression config entry
    */
    static
    QString skipCompression()
    {
      return self()->mSkipCompression;
    }

    /**
      Is The value(s) for the UseSkipCompression config entry Immutable
    */
    static
    bool isSkipCompressionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SkipCompression" ) );
    }

    /**
      Get Item object corresponding to SkipCompression()
    */
    ItemString *skipCompressionItem()
    {
      return mSkipCompressionItem;
    }

    /**
      Set Preserve symlinks
    */
    static
    void setPreserveSymlinks( bool v )
    {
      if (!self()->isPreserveSymlinksImmutable())
        self()->mPreserveSymlinks = v;
    }

    /**
      Get Preserve symlinks
    */
    static
    bool preserveSymlinks()
    {
      return self()->mPreserveSymlinks;
    }

    /**
      Is Preserve symlinks Immutable
    */
    static
    bool isPreserveSymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveSymlinks" ) );
    }

    /**
      Get Item object corresponding to PreserveSymlinks()
    */
    ItemBool *preserveSymlinksItem()
    {
      return mPreserveSymlinksItem;
    }

    /**
      Set Transform symlinks
    */
    static
    void setTransformSymlinks( bool v )
    {
      if (!self()->isTransformSymlinksImmutable())
        self()->mTransformSymlinks = v;
    }

    /**
      Get Transform symlinks
    */
    static
    bool transformSymlinks()
    {
      return self()->mTransformSymlinks;
    }

    /**
      Is Transform symlinks Immutable
    */
    static
    bool isTransformSymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TransformSymlinks" ) );
    }

    /**
      Get Item object corresponding to TransformSymlinks()
    */
    ItemBool *transformSymlinksItem()
    {
      return mTransformSymlinksItem;
    }

    /**
      Set Transform unsafe symlinks
    */
    static
    void setTransformUnsafeSymlinks( bool v )
    {
      if (!self()->isTransformUnsafeSymlinksImmutable())
        self()->mTransformUnsafeSymlinks = v;
    }

    /**
      Get Transform unsafe symlinks
    */
    static
    bool transformUnsafeSymlinks()
    {
      return self()->mTransformUnsafeSymlinks;
    }

    /**
      Is Transform unsafe symlinks Immutable
    */
    static
    bool isTransformUnsafeSymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TransformUnsafeSymlinks" ) );
    }

    /**
      Get Item object corresponding to TransformUnsafeSymlinks()
    */
    ItemBool *transformUnsafeSymlinksItem()
    {
      return mTransformUnsafeSymlinksItem;
    }

    /**
      Set Ignore unsafe symlinks
    */
    static
    void setIgnoreUnsafeSymlinks( bool v )
    {
      if (!self()->isIgnoreUnsafeSymlinksImmutable())
        self()->mIgnoreUnsafeSymlinks = v;
    }

    /**
      Get Ignore unsafe symlinks
    */
    static
    bool ignoreUnsafeSymlinks()
    {
      return self()->mIgnoreUnsafeSymlinks;
    }

    /**
      Is Ignore unsafe symlinks Immutable
    */
    static
    bool isIgnoreUnsafeSymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IgnoreUnsafeSymlinks" ) );
    }

    /**
      Get Item object corresponding to IgnoreUnsafeSymlinks()
    */
    ItemBool *ignoreUnsafeSymlinksItem()
    {
      return mIgnoreUnsafeSymlinksItem;
    }

    /**
      Set Munge symlinks
    */
    static
    void setMungeSymlinks( bool v )
    {
      if (!self()->isMungeSymlinksImmutable())
        self()->mMungeSymlinks = v;
    }

    /**
      Get Munge symlinks
    */
    static
    bool mungeSymlinks()
    {
      return self()->mMungeSymlinks;
    }

    /**
      Is Munge symlinks Immutable
    */
    static
    bool isMungeSymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MungeSymlinks" ) );
    }

    /**
      Get Item object corresponding to MungeSymlinks()
    */
    ItemBool *mungeSymlinksItem()
    {
      return mMungeSymlinksItem;
    }

    /**
      Set Preserve hard links
    */
    static
    void setPreserveHardLinks( bool v )
    {
      if (!self()->isPreserveHardLinksImmutable())
        self()->mPreserveHardLinks = v;
    }

    /**
      Get Preserve hard links
    */
    static
    bool preserveHardLinks()
    {
      return self()->mPreserveHardLinks;
    }

    /**
      Is Preserve hard links Immutable
    */
    static
    bool isPreserveHardLinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveHardLinks" ) );
    }

    /**
      Get Item object corresponding to PreserveHardLinks()
    */
    ItemBool *preserveHardLinksItem()
    {
      return mPreserveHardLinksItem;
    }

    /**
      Set Copy directory symlinks
    */
    static
    void setCopyDirectorySymlinks( bool v )
    {
      if (!self()->isCopyDirectorySymlinksImmutable())
        self()->mCopyDirectorySymlinks = v;
    }

    /**
      Get Copy directory symlinks
    */
    static
    bool copyDirectorySymlinks()
    {
      return self()->mCopyDirectorySymlinks;
    }

    /**
      Is Copy directory symlinks Immutable
    */
    static
    bool isCopyDirectorySymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CopyDirectorySymlinks" ) );
    }

    /**
      Get Item object corresponding to CopyDirectorySymlinks()
    */
    ItemBool *copyDirectorySymlinksItem()
    {
      return mCopyDirectorySymlinksItem;
    }

    /**
      Set Keep directory symlinks
    */
    static
    void setKeepDirectorySymlinks( bool v )
    {
      if (!self()->isKeepDirectorySymlinksImmutable())
        self()->mKeepDirectorySymlinks = v;
    }

    /**
      Get Keep directory symlinks
    */
    static
    bool keepDirectorySymlinks()
    {
      return self()->mKeepDirectorySymlinks;
    }

    /**
      Is Keep directory symlinks Immutable
    */
    static
    bool isKeepDirectorySymlinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "KeepDirectorySymlinks" ) );
    }

    /**
      Get Item object corresponding to KeepDirectorySymlinks()
    */
    ItemBool *keepDirectorySymlinksItem()
    {
      return mKeepDirectorySymlinksItem;
    }

    /**
      Set Preserve permissions
    */
    static
    void setPreservePermissions( bool v )
    {
      if (!self()->isPreservePermissionsImmutable())
        self()->mPreservePermissions = v;
    }

    /**
      Get Preserve permissions
    */
    static
    bool preservePermissions()
    {
      return self()->mPreservePermissions;
    }

    /**
      Is Preserve permissions Immutable
    */
    static
    bool isPreservePermissionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreservePermissions" ) );
    }

    /**
      Get Item object corresponding to PreservePermissions()
    */
    ItemBool *preservePermissionsItem()
    {
      return mPreservePermissionsItem;
    }

    /**
      Set Preserve access control lists (ACLs)
    */
    static
    void setPreserveACLs( bool v )
    {
      if (!self()->isPreserveACLsImmutable())
        self()->mPreserveACLs = v;
    }

    /**
      Get Preserve access control lists (ACLs)
    */
    static
    bool preserveACLs()
    {
      return self()->mPreserveACLs;
    }

    /**
      Is Preserve access control lists (ACLs) Immutable
    */
    static
    bool isPreserveACLsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveACLs" ) );
    }

    /**
      Get Item object corresponding to PreserveACLs()
    */
    ItemBool *preserveACLsItem()
    {
      return mPreserveACLsItem;
    }

    /**
      Set Preserve extended attributes
    */
    static
    void setPreserveExtendedAttributes( bool v )
    {
      if (!self()->isPreserveExtendedAttributesImmutable())
        self()->mPreserveExtendedAttributes = v;
    }

    /**
      Get Preserve extended attributes
    */
    static
    bool preserveExtendedAttributes()
    {
      return self()->mPreserveExtendedAttributes;
    }

    /**
      Is Preserve extended attributes Immutable
    */
    static
    bool isPreserveExtendedAttributesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveExtendedAttributes" ) );
    }

    /**
      Get Item object corresponding to PreserveExtendedAttributes()
    */
    ItemBool *preserveExtendedAttributesItem()
    {
      return mPreserveExtendedAttributesItem;
    }

    /**
      Set Preserve access times
    */
    static
    void setPreserveAccessTimes( bool v )
    {
      if (!self()->isPreserveAccessTimesImmutable())
        self()->mPreserveAccessTimes = v;
    }

    /**
      Get Preserve access times
    */
    static
    bool preserveAccessTimes()
    {
      return self()->mPreserveAccessTimes;
    }

    /**
      Is Preserve access times Immutable
    */
    static
    bool isPreserveAccessTimesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveAccessTimes" ) );
    }

    /**
      Get Item object corresponding to PreserveAccessTimes()
    */
    ItemBool *preserveAccessTimesItem()
    {
      return mPreserveAccessTimesItem;
    }

    /**
      Set Preserve create times
    */
    static
    void setPreserveCreateTimes( bool v )
    {
      if (!self()->isPreserveCreateTimesImmutable())
        self()->mPreserveCreateTimes = v;
    }

    /**
      Get Preserve create times
    */
    static
    bool preserveCreateTimes()
    {
      return self()->mPreserveCreateTimes;
    }

    /**
      Is Preserve create times Immutable
    */
    static
    bool isPreserveCreateTimesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveCreateTimes" ) );
    }

    /**
      Get Item object corresponding to PreserveCreateTimes()
    */
    ItemBool *preserveCreateTimesItem()
    {
      return mPreserveCreateTimesItem;
    }

    /**
      Set Preserve group
    */
    static
    void setPreserveGroup( bool v )
    {
      if (!self()->isPreserveGroupImmutable())
        self()->mPreserveGroup = v;
    }

    /**
      Get Preserve group
    */
    static
    bool preserveGroup()
    {
      return self()->mPreserveGroup;
    }

    /**
      Is Preserve group Immutable
    */
    static
    bool isPreserveGroupImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveGroup" ) );
    }

    /**
      Get Item object corresponding to PreserveGroup()
    */
    ItemBool *preserveGroupItem()
    {
      return mPreserveGroupItem;
    }

    /**
      Set Preserve owner
    */
    static
    void setPreserveOwner( bool v )
    {
      if (!self()->isPreserveOwnerImmutable())
        self()->mPreserveOwner = v;
    }

    /**
      Get Preserve owner
    */
    static
    bool preserveOwner()
    {
      return self()->mPreserveOwner;
    }

    /**
      Is Preserve owner Immutable
    */
    static
    bool isPreserveOwnerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveOwner" ) );
    }

    /**
      Get Item object corresponding to PreserveOwner()
    */
    ItemBool *preserveOwnerItem()
    {
      return mPreserveOwnerItem;
    }

    /**
      Set Preserve device and special files
    */
    static
    void setPreserveDevicesAndSpecials( bool v )
    {
      if (!self()->isPreserveDevicesAndSpecialsImmutable())
        self()->mPreserveDevicesAndSpecials = v;
    }

    /**
      Get Preserve device and special files
    */
    static
    bool preserveDevicesAndSpecials()
    {
      return self()->mPreserveDevicesAndSpecials;
    }

    /**
      Is Preserve device and special files Immutable
    */
    static
    bool isPreserveDevicesAndSpecialsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveDevicesAndSpecials" ) );
    }

    /**
      Get Item object corresponding to PreserveDevicesAndSpecials()
    */
    ItemBool *preserveDevicesAndSpecialsItem()
    {
      return mPreserveDevicesAndSpecialsItem;
    }

    /**
      Set Preserve times
    */
    static
    void setPreserveTimes( bool v )
    {
      if (!self()->isPreserveTimesImmutable())
        self()->mPreserveTimes = v;
    }

    /**
      Get Preserve times
    */
    static
    bool preserveTimes()
    {
      return self()->mPreserveTimes;
    }

    /**
      Is Preserve times Immutable
    */
    static
    bool isPreserveTimesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreserveTimes" ) );
    }

    /**
      Get Item object corresponding to PreserveTimes()
    */
    ItemBool *preserveTimesItem()
    {
      return mPreserveTimesItem;
    }

    /**
      Set Omit directories when preserving times
    */
    static
    void setOmitDirectoryTimes( bool v )
    {
      if (!self()->isOmitDirectoryTimesImmutable())
        self()->mOmitDirectoryTimes = v;
    }

    /**
      Get Omit directories when preserving times
    */
    static
    bool omitDirectoryTimes()
    {
      return self()->mOmitDirectoryTimes;
    }

    /**
      Is Omit directories when preserving times Immutable
    */
    static
    bool isOmitDirectoryTimesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "OmitDirectoryTimes" ) );
    }

    /**
      Get Item object corresponding to OmitDirectoryTimes()
    */
    ItemBool *omitDirectoryTimesItem()
    {
      return mOmitDirectoryTimesItem;
    }

    /**
      Set Remove synchronized source files
    */
    static
    void setRemoveSourceFiles( bool v )
    {
      if (!self()->isRemoveSourceFilesImmutable())
        self()->mRemoveSourceFiles = v;
    }

    /**
      Get Remove synchronized source files
    */
    static
    bool removeSourceFiles()
    {
      return self()->mRemoveSourceFiles;
    }

    /**
      Is Remove synchronized source files Immutable
    */
    static
    bool isRemoveSourceFilesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RemoveSourceFiles" ) );
    }

    /**
      Get Item object corresponding to RemoveSourceFiles()
    */
    ItemBool *removeSourceFilesItem()
    {
      return mRemoveSourceFilesItem;
    }

    /**
      Set Delete extraneous files
    */
    static
    void setDeleteExtraneous( bool v )
    {
      if (!self()->isDeleteExtraneousImmutable())
        self()->mDeleteExtraneous = v;
    }

    /**
      Get Delete extraneous files
    */
    static
    bool deleteExtraneous()
    {
      return self()->mDeleteExtraneous;
    }

    /**
      Is Delete extraneous files Immutable
    */
    static
    bool isDeleteExtraneousImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DeleteExtraneous" ) );
    }

    /**
      Get Item object corresponding to DeleteExtraneous()
    */
    ItemBool *deleteExtraneousItem()
    {
      return mDeleteExtraneousItem;
    }

    /**
      Set Delete files before transfer
    */
    static
    void setDeleteBefore( bool v )
    {
      if (!self()->isDeleteBeforeImmutable())
        self()->mDeleteBefore = v;
    }

    /**
      Get Delete files before transfer
    */
    static
    bool deleteBefore()
    {
      return self()->mDeleteBefore;
    }

    /**
      Is Delete files before transfer Immutable
    */
    static
    bool isDeleteBeforeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DeleteBefore" ) );
    }

    /**
      Get Item object corresponding to DeleteBefore()
    */
    ItemBool *deleteBeforeItem()
    {
      return mDeleteBeforeItem;
    }

    /**
      Set Delete files after transfer
    */
    static
    void setDeleteAfter( bool v )
    {
      if (!self()->isDeleteAfterImmutable())
        self()->mDeleteAfter = v;
    }

    /**
      Get Delete files after transfer
    */
    static
    bool deleteAfter()
    {
      return self()->mDeleteAfter;
    }

    /**
      Is Delete files after transfer Immutable
    */
    static
    bool isDeleteAfterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DeleteAfter" ) );
    }

    /**
      Get Item object corresponding to DeleteAfter()
    */
    ItemBool *deleteAfterItem()
    {
      return mDeleteAfterItem;
    }

    /**
      Set Delete files during transfer
    */
    static
    void setDeleteDuring( bool v )
    {
      if (!self()->isDeleteDuringImmutable())
        self()->mDeleteDuring = v;
    }

    /**
      Get Delete files during transfer
    */
    static
    bool deleteDuring()
    {
      return self()->mDeleteDuring;
    }

    /**
      Is Delete files during transfer Immutable
    */
    static
    bool isDeleteDuringImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DeleteDuring" ) );
    }

    /**
      Get Item object corresponding to DeleteDuring()
    */
    ItemBool *deleteDuringItem()
    {
      return mDeleteDuringItem;
    }

    /**
      Set Delete excluded files
    */
    static
    void setDeleteExcluded( bool v )
    {
      if (!self()->isDeleteExcludedImmutable())
        self()->mDeleteExcluded = v;
    }

    /**
      Get Delete excluded files
    */
    static
    bool deleteExcluded()
    {
      return self()->mDeleteExcluded;
    }

    /**
      Is Delete excluded files Immutable
    */
    static
    bool isDeleteExcludedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DeleteExcluded" ) );
    }

    /**
      Get Item object corresponding to DeleteExcluded()
    */
    ItemBool *deleteExcludedItem()
    {
      return mDeleteExcludedItem;
    }

    /**
      Set Delete even if I/O errors occur
    */
    static
    void setIgnoreErrors( bool v )
    {
      if (!self()->isIgnoreErrorsImmutable())
        self()->mIgnoreErrors = v;
    }

    /**
      Get Delete even if I/O errors occur
    */
    static
    bool ignoreErrors()
    {
      return self()->mIgnoreErrors;
    }

    /**
      Is Delete even if I/O errors occur Immutable
    */
    static
    bool isIgnoreErrorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IgnoreErrors" ) );
    }

    /**
      Get Item object corresponding to IgnoreErrors()
    */
    ItemBool *ignoreErrorsItem()
    {
      return mIgnoreErrorsItem;
    }

    /**
      Set Force deletion of non-void directories
    */
    static
    void setForceDirectoryDeletion( bool v )
    {
      if (!self()->isForceDirectoryDeletionImmutable())
        self()->mForceDirectoryDeletion = v;
    }

    /**
      Get Force deletion of non-void directories
    */
    static
    bool forceDirectoryDeletion()
    {
      return self()->mForceDirectoryDeletion;
    }

    /**
      Is Force deletion of non-void directories Immutable
    */
    static
    bool isForceDirectoryDeletionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ForceDirectoryDeletion" ) );
    }

    /**
      Get Item object corresponding to ForceDirectoryDeletion()
    */
    ItemBool *forceDirectoryDeletionItem()
    {
      return mForceDirectoryDeletionItem;
    }

    /**
      Set Do not delete more than this many files:
    */
    static
    void setUseMaximumDelete( bool v )
    {
      if (!self()->isUseMaximumDeleteImmutable())
        self()->mUseMaximumDelete = v;
    }

    /**
      Get Do not delete more than this many files:
    */
    static
    bool useMaximumDelete()
    {
      return self()->mUseMaximumDelete;
    }

    /**
      Is Do not delete more than this many files: Immutable
    */
    static
    bool isUseMaximumDeleteImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseMaximumDelete" ) );
    }

    /**
      Get Item object corresponding to UseMaximumDelete()
    */
    ItemBool *useMaximumDeleteItem()
    {
      return mUseMaximumDeleteItem;
    }

    /**
      Set Value for DeleteMaximum config entry
    */
    static
    void setMaximumDeleteValue( int v )
    {
      if (v < 0)
      {
        qDebug() << "setMaximumDeleteValue: value " << v << " is less than the minimum value of 0";
        v = 0;
      }
      if (!self()->isMaximumDeleteValueImmutable())
        self()->mMaximumDeleteValue = v;
    }

    /**
      Get Value for DeleteMaximum config entry
    */
    static
    int maximumDeleteValue()
    {
      return self()->mMaximumDeleteValue;
    }

    /**
      Is Value for DeleteMaximum config entry Immutable
    */
    static
    bool isMaximumDeleteValueImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaximumDeleteValue" ) );
    }

    /**
      Get Item object corresponding to MaximumDeleteValue()
    */
    ItemInt *maximumDeleteValueItem()
    {
      return mMaximumDeleteValueItem;
    }

    /**
      Set Do not transfer any file smaller than:
    */
    static
    void setUseMinimalTransferSize( bool v )
    {
      if (!self()->isUseMinimalTransferSizeImmutable())
        self()->mUseMinimalTransferSize = v;
    }

    /**
      Get Do not transfer any file smaller than:
    */
    static
    bool useMinimalTransferSize()
    {
      return self()->mUseMinimalTransferSize;
    }

    /**
      Is Do not transfer any file smaller than: Immutable
    */
    static
    bool isUseMinimalTransferSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseMinimalTransferSize" ) );
    }

    /**
      Get Item object corresponding to UseMinimalTransferSize()
    */
    ItemBool *useMinimalTransferSizeItem()
    {
      return mUseMinimalTransferSizeItem;
    }

    /**
      Set Value for MinimalTransferSize config entry
    */
    static
    void setMinimalTransferSize( int v )
    {
      if (v < 0)
      {
        qDebug() << "setMinimalTransferSize: value " << v << " is less than the minimum value of 0";
        v = 0;
      }
      if (!self()->isMinimalTransferSizeImmutable())
        self()->mMinimalTransferSize = v;
    }

    /**
      Get Value for MinimalTransferSize config entry
    */
    static
    int minimalTransferSize()
    {
      return self()->mMinimalTransferSize;
    }

    /**
      Is Value for MinimalTransferSize config entry Immutable
    */
    static
    bool isMinimalTransferSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MinimalTransferSize" ) );
    }

    /**
      Get Item object corresponding to MinimalTransferSize()
    */
    ItemInt *minimalTransferSizeItem()
    {
      return mMinimalTransferSizeItem;
    }

    /**
      Set Do not transfer any file larger than:
    */
    static
    void setUseMaximalTransferSize( bool v )
    {
      if (!self()->isUseMaximalTransferSizeImmutable())
        self()->mUseMaximalTransferSize = v;
    }

    /**
      Get Do not transfer any file larger than:
    */
    static
    bool useMaximalTransferSize()
    {
      return self()->mUseMaximalTransferSize;
    }

    /**
      Is Do not transfer any file larger than: Immutable
    */
    static
    bool isUseMaximalTransferSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseMaximalTransferSize" ) );
    }

    /**
      Get Item object corresponding to UseMaximalTransferSize()
    */
    ItemBool *useMaximalTransferSizeItem()
    {
      return mUseMaximalTransferSizeItem;
    }

    /**
      Set Value for MaximalTransferSize config entry
    */
    static
    void setMaximalTransferSize( int v )
    {
      if (v < 0)
      {
        qDebug() << "setMaximalTransferSize: value " << v << " is less than the minimum value of 0";
        v = 0;
      }
      if (!self()->isMaximalTransferSizeImmutable())
        self()->mMaximalTransferSize = v;
    }

    /**
      Get Value for MaximalTransferSize config entry
    */
    static
    int maximalTransferSize()
    {
      return self()->mMaximalTransferSize;
    }

    /**
      Is Value for MaximalTransferSize config entry Immutable
    */
    static
    bool isMaximalTransferSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaximalTransferSize" ) );
    }

    /**
      Get Item object corresponding to MaximalTransferSize()
    */
    ItemInt *maximalTransferSizeItem()
    {
      return mMaximalTransferSizeItem;
    }

    /**
      Set Keep partially transferred files
    */
    static
    void setKeepPartial( bool v )
    {
      if (!self()->isKeepPartialImmutable())
        self()->mKeepPartial = v;
    }

    /**
      Get Keep partially transferred files
    */
    static
    bool keepPartial()
    {
      return self()->mKeepPartial;
    }

    /**
      Is Keep partially transferred files Immutable
    */
    static
    bool isKeepPartialImmutable()
    {
      return self()->isImmutable( QStringLiteral( "KeepPartial" ) );
    }

    /**
      Get Item object corresponding to KeepPartial()
    */
    ItemBool *keepPartialItem()
    {
      return mKeepPartialItem;
    }

    /**
      Set Put partially transferred files into:
    */
    static
    void setUsePartialDirectory( bool v )
    {
      if (!self()->isUsePartialDirectoryImmutable())
        self()->mUsePartialDirectory = v;
    }

    /**
      Get Put partially transferred files into:
    */
    static
    bool usePartialDirectory()
    {
      return self()->mUsePartialDirectory;
    }

    /**
      Is Put partially transferred files into: Immutable
    */
    static
    bool isUsePartialDirectoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UsePartialDirectory" ) );
    }

    /**
      Get Item object corresponding to UsePartialDirectory()
    */
    ItemBool *usePartialDirectoryItem()
    {
      return mUsePartialDirectoryItem;
    }

    /**
      Set The data for the UsePartialDirectory option
    */
    static
    void setPartialDirectory( const QUrl & v )
    {
      if (!self()->isPartialDirectoryImmutable())
        self()->mPartialDirectory = v;
    }

    /**
      Get The data for the UsePartialDirectory option
    */
    static
    QUrl partialDirectory()
    {
      return self()->mPartialDirectory;
    }

    /**
      Is The data for the UsePartialDirectory option Immutable
    */
    static
    bool isPartialDirectoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PartialDirectory" ) );
    }

    /**
      Get Item object corresponding to PartialDirectory()
    */
    ItemUrl *partialDirectoryItem()
    {
      return mPartialDirectoryItem;
    }

    /**
      Set Auto-ignore files in the same way CVS does
    */
    static
    void setUseCVSExclude( bool v )
    {
      if (!self()->isUseCVSExcludeImmutable())
        self()->mUseCVSExclude = v;
    }

    /**
      Get Auto-ignore files in the same way CVS does
    */
    static
    bool useCVSExclude()
    {
      return self()->mUseCVSExclude;
    }

    /**
      Is Auto-ignore files in the same way CVS does Immutable
    */
    static
    bool isUseCVSExcludeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseCVSExclude" ) );
    }

    /**
      Get Item object corresponding to UseCVSExclude()
    */
    ItemBool *useCVSExcludeItem()
    {
      return mUseCVSExcludeItem;
    }

    /**
      Set Exclude files matching this pattern:
    */
    static
    void setUseExcludePattern( bool v )
    {
      if (!self()->isUseExcludePatternImmutable())
        self()->mUseExcludePattern = v;
    }

    /**
      Get Exclude files matching this pattern:
    */
    static
    bool useExcludePattern()
    {
      return self()->mUseExcludePattern;
    }

    /**
      Is Exclude files matching this pattern: Immutable
    */
    static
    bool isUseExcludePatternImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseExcludePattern" ) );
    }

    /**
      Get Item object corresponding to UseExcludePattern()
    */
    ItemBool *useExcludePatternItem()
    {
      return mUseExcludePatternItem;
    }

    /**
      Set Pattern that is used for file exclusion
    */
    static
    void setExcludePattern( const QString & v )
    {
      if (!self()->isExcludePatternImmutable())
        self()->mExcludePattern = v;
    }

    /**
      Get Pattern that is used for file exclusion
    */
    static
    QString excludePattern()
    {
      return self()->mExcludePattern;
    }

    /**
      Is Pattern that is used for file exclusion Immutable
    */
    static
    bool isExcludePatternImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExcludePattern" ) );
    }

    /**
      Get Item object corresponding to ExcludePattern()
    */
    ItemString *excludePatternItem()
    {
      return mExcludePatternItem;
    }

    /**
      Set Read exclude patterns from:
    */
    static
    void setUseExcludeFrom( bool v )
    {
      if (!self()->isUseExcludeFromImmutable())
        self()->mUseExcludeFrom = v;
    }

    /**
      Get Read exclude patterns from:
    */
    static
    bool useExcludeFrom()
    {
      return self()->mUseExcludeFrom;
    }

    /**
      Is Read exclude patterns from: Immutable
    */
    static
    bool isUseExcludeFromImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseExcludeFrom" ) );
    }

    /**
      Get Item object corresponding to UseExcludeFrom()
    */
    ItemBool *useExcludeFromItem()
    {
      return mUseExcludeFromItem;
    }

    /**
      Set The file from which the exclude patterns are read
    */
    static
    void setExcludeFrom( const QUrl & v )
    {
      if (!self()->isExcludeFromImmutable())
        self()->mExcludeFrom = v;
    }

    /**
      Get The file from which the exclude patterns are read
    */
    static
    QUrl excludeFrom()
    {
      return self()->mExcludeFrom;
    }

    /**
      Is The file from which the exclude patterns are read Immutable
    */
    static
    bool isExcludeFromImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExcludeFrom" ) );
    }

    /**
      Get Item object corresponding to ExcludeFrom()
    */
    ItemUrl *excludeFromItem()
    {
      return mExcludeFromItem;
    }

    /**
      Set Include files matching this pattern:
    */
    static
    void setUseIncludePattern( bool v )
    {
      if (!self()->isUseIncludePatternImmutable())
        self()->mUseIncludePattern = v;
    }

    /**
      Get Include files matching this pattern:
    */
    static
    bool useIncludePattern()
    {
      return self()->mUseIncludePattern;
    }

    /**
      Is Include files matching this pattern: Immutable
    */
    static
    bool isUseIncludePatternImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseIncludePattern" ) );
    }

    /**
      Get Item object corresponding to UseIncludePattern()
    */
    ItemBool *useIncludePatternItem()
    {
      return mUseIncludePatternItem;
    }

    /**
      Set Pattern that is used for file inclusion
    */
    static
    void setIncludePattern( const QString & v )
    {
      if (!self()->isIncludePatternImmutable())
        self()->mIncludePattern = v;
    }

    /**
      Get Pattern that is used for file inclusion
    */
    static
    QString includePattern()
    {
      return self()->mIncludePattern;
    }

    /**
      Is Pattern that is used for file inclusion Immutable
    */
    static
    bool isIncludePatternImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IncludePattern" ) );
    }

    /**
      Get Item object corresponding to IncludePattern()
    */
    ItemString *includePatternItem()
    {
      return mIncludePatternItem;
    }

    /**
      Set Read include patterns from:
    */
    static
    void setUseIncludeFrom( bool v )
    {
      if (!self()->isUseIncludeFromImmutable())
        self()->mUseIncludeFrom = v;
    }

    /**
      Get Read include patterns from:
    */
    static
    bool useIncludeFrom()
    {
      return self()->mUseIncludeFrom;
    }

    /**
      Is Read include patterns from: Immutable
    */
    static
    bool isUseIncludeFromImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseIncludeFrom" ) );
    }

    /**
      Get Item object corresponding to UseIncludeFrom()
    */
    ItemBool *useIncludeFromItem()
    {
      return mUseIncludeFromItem;
    }

    /**
      Set The file from which the include patterns are read
    */
    static
    void setIncludeFrom( const QUrl & v )
    {
      if (!self()->isIncludeFromImmutable())
        self()->mIncludeFrom = v;
    }

    /**
      Get The file from which the include patterns are read
    */
    static
    QUrl includeFrom()
    {
      return self()->mIncludeFrom;
    }

    /**
      Is The file from which the include patterns are read Immutable
    */
    static
    bool isIncludeFromImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IncludeFrom" ) );
    }

    /**
      Get Item object corresponding to IncludeFrom()
    */
    ItemUrl *includeFromItem()
    {
      return mIncludeFromItem;
    }

    /**
      Set Custom filter rules:
    */
    static
    void setUseCustomFilteringRules( bool v )
    {
      if (!self()->isUseCustomFilteringRulesImmutable())
        self()->mUseCustomFilteringRules = v;
    }

    /**
      Get Custom filter rules:
    */
    static
    bool useCustomFilteringRules()
    {
      return self()->mUseCustomFilteringRules;
    }

    /**
      Is Custom filter rules: Immutable
    */
    static
    bool isUseCustomFilteringRulesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseCustomFilteringRules" ) );
    }

    /**
      Get Item object corresponding to UseCustomFilteringRules()
    */
    ItemBool *useCustomFilteringRulesItem()
    {
      return mUseCustomFilteringRulesItem;
    }

    /**
      Set Custom filter rules
    */
    static
    void setCustomFilteringRules( const QString & v )
    {
      if (!self()->isCustomFilteringRulesImmutable())
        self()->mCustomFilteringRules = v;
    }

    /**
      Get Custom filter rules
    */
    static
    QString customFilteringRules()
    {
      return self()->mCustomFilteringRules;
    }

    /**
      Is Custom filter rules Immutable
    */
    static
    bool isCustomFilteringRulesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CustomFilteringRules" ) );
    }

    /**
      Get Item object corresponding to CustomFilteringRules()
    */
    ItemString *customFilteringRulesItem()
    {
      return mCustomFilteringRulesItem;
    }

    /**
      Set Use --filter='dir-merge /.rsync-filter' filter rule
    */
    static
    void setUseFFilterRule( bool v )
    {
      if (!self()->isUseFFilterRuleImmutable())
        self()->mUseFFilterRule = v;
    }

    /**
      Get Use --filter='dir-merge /.rsync-filter' filter rule
    */
    static
    bool useFFilterRule()
    {
      return self()->mUseFFilterRule;
    }

    /**
      Is Use --filter='dir-merge /.rsync-filter' filter rule Immutable
    */
    static
    bool isUseFFilterRuleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseFFilterRule" ) );
    }

    /**
      Get Item object corresponding to UseFFilterRule()
    */
    ItemBool *useFFilterRuleItem()
    {
      return mUseFFilterRuleItem;
    }

    /**
      Set Use --filter='exclude .rsync-filter' filter rule
    */
    static
    void setUseFFFilterRule( bool v )
    {
      if (!self()->isUseFFFilterRuleImmutable())
        self()->mUseFFFilterRule = v;
    }

    /**
      Get Use --filter='exclude .rsync-filter' filter rule
    */
    static
    bool useFFFilterRule()
    {
      return self()->mUseFFFilterRule;
    }

    /**
      Is Use --filter='exclude .rsync-filter' filter rule Immutable
    */
    static
    bool isUseFFFilterRuleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseFFFilterRule" ) );
    }

    /**
      Get Item object corresponding to UseFFFilterRule()
    */
    ItemBool *useFFFilterRuleItem()
    {
      return mUseFFFilterRuleItem;
    }

    /**
      Set Handle sparse files efficiently
    */
    static
    void setEfficientSparseFileHandling( bool v )
    {
      if (!self()->isEfficientSparseFileHandlingImmutable())
        self()->mEfficientSparseFileHandling = v;
    }

    /**
      Get Handle sparse files efficiently
    */
    static
    bool efficientSparseFileHandling()
    {
      return self()->mEfficientSparseFileHandling;
    }

    /**
      Is Handle sparse files efficiently Immutable
    */
    static
    bool isEfficientSparseFileHandlingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EfficientSparseFileHandling" ) );
    }

    /**
      Get Item object corresponding to EfficientSparseFileHandling()
    */
    ItemBool *efficientSparseFileHandlingItem()
    {
      return mEfficientSparseFileHandlingItem;
    }

    /**
      Set Copy files whole (no rsync algorithm)
    */
    static
    void setCopyFilesWhole( bool v )
    {
      if (!self()->isCopyFilesWholeImmutable())
        self()->mCopyFilesWhole = v;
    }

    /**
      Get Copy files whole (no rsync algorithm)
    */
    static
    bool copyFilesWhole()
    {
      return self()->mCopyFilesWhole;
    }

    /**
      Is Copy files whole (no rsync algorithm) Immutable
    */
    static
    bool isCopyFilesWholeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CopyFilesWhole" ) );
    }

    /**
      Get Item object corresponding to CopyFilesWhole()
    */
    ItemBool *copyFilesWholeItem()
    {
      return mCopyFilesWholeItem;
    }

    /**
      Set Do not cross file system boundaries
    */
    static
    void setOneFileSystem( bool v )
    {
      if (!self()->isOneFileSystemImmutable())
        self()->mOneFileSystem = v;
    }

    /**
      Get Do not cross file system boundaries
    */
    static
    bool oneFileSystem()
    {
      return self()->mOneFileSystem;
    }

    /**
      Is Do not cross file system boundaries Immutable
    */
    static
    bool isOneFileSystemImmutable()
    {
      return self()->isImmutable( QStringLiteral( "OneFileSystem" ) );
    }

    /**
      Get Item object corresponding to OneFileSystem()
    */
    ItemBool *oneFileSystemItem()
    {
      return mOneFileSystemItem;
    }

    /**
      Set Only update files that already exist
    */
    static
    void setUpdateExisting( bool v )
    {
      if (!self()->isUpdateExistingImmutable())
        self()->mUpdateExisting = v;
    }

    /**
      Get Only update files that already exist
    */
    static
    bool updateExisting()
    {
      return self()->mUpdateExisting;
    }

    /**
      Is Only update files that already exist Immutable
    */
    static
    bool isUpdateExistingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UpdateExisting" ) );
    }

    /**
      Get Item object corresponding to UpdateExisting()
    */
    ItemBool *updateExistingItem()
    {
      return mUpdateExistingItem;
    }

    /**
      Set Ignore files that already exist
    */
    static
    void setIgnoreExisting( bool v )
    {
      if (!self()->isIgnoreExistingImmutable())
        self()->mIgnoreExisting = v;
    }

    /**
      Get Ignore files that already exist
    */
    static
    bool ignoreExisting()
    {
      return self()->mIgnoreExisting;
    }

    /**
      Is Ignore files that already exist Immutable
    */
    static
    bool isIgnoreExistingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IgnoreExisting" ) );
    }

    /**
      Get Item object corresponding to IgnoreExisting()
    */
    ItemBool *ignoreExistingItem()
    {
      return mIgnoreExistingItem;
    }

    /**
      Set Delay updates until the end of transfer
    */
    static
    void setDelayUpdates( bool v )
    {
      if (!self()->isDelayUpdatesImmutable())
        self()->mDelayUpdates = v;
    }

    /**
      Get Delay updates until the end of transfer
    */
    static
    bool delayUpdates()
    {
      return self()->mDelayUpdates;
    }

    /**
      Is Delay updates until the end of transfer Immutable
    */
    static
    bool isDelayUpdatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DelayUpdates" ) );
    }

    /**
      Get Item object corresponding to DelayUpdates()
    */
    ItemBool *delayUpdatesItem()
    {
      return mDelayUpdatesItem;
    }

    /**
      Set Make backups
    */
    static
    void setMakeBackups( bool v )
    {
      if (!self()->isMakeBackupsImmutable())
        self()->mMakeBackups = v;
    }

    /**
      Get Make backups
    */
    static
    bool makeBackups()
    {
      return self()->mMakeBackups;
    }

    /**
      Is Make backups Immutable
    */
    static
    bool isMakeBackupsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MakeBackups" ) );
    }

    /**
      Get Item object corresponding to MakeBackups()
    */
    ItemBool *makeBackupsItem()
    {
      return mMakeBackupsItem;
    }

    /**
      Set Backup suffix:
    */
    static
    void setUseBackupSuffix( bool v )
    {
      if (!self()->isUseBackupSuffixImmutable())
        self()->mUseBackupSuffix = v;
    }

    /**
      Get Backup suffix:
    */
    static
    bool useBackupSuffix()
    {
      return self()->mUseBackupSuffix;
    }

    /**
      Is Backup suffix: Immutable
    */
    static
    bool isUseBackupSuffixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseBackupSuffix" ) );
    }

    /**
      Get Item object corresponding to UseBackupSuffix()
    */
    ItemBool *useBackupSuffixItem()
    {
      return mUseBackupSuffixItem;
    }

    /**
      Set Backup suffix
    */
    static
    void setBackupSuffix( const QString & v )
    {
      if (!self()->isBackupSuffixImmutable())
        self()->mBackupSuffix = v;
    }

    /**
      Get Backup suffix
    */
    static
    QString backupSuffix()
    {
      return self()->mBackupSuffix;
    }

    /**
      Is Backup suffix Immutable
    */
    static
    bool isBackupSuffixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackupSuffix" ) );
    }

    /**
      Get Item object corresponding to BackupSuffix()
    */
    ItemString *backupSuffixItem()
    {
      return mBackupSuffixItem;
    }

    /**
      Set Backup directory:
    */
    static
    void setUseBackupDirectory( bool v )
    {
      if (!self()->isUseBackupDirectoryImmutable())
        self()->mUseBackupDirectory = v;
    }

    /**
      Get Backup directory:
    */
    static
    bool useBackupDirectory()
    {
      return self()->mUseBackupDirectory;
    }

    /**
      Is Backup directory: Immutable
    */
    static
    bool isUseBackupDirectoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseBackupDirectory" ) );
    }

    /**
      Get Item object corresponding to UseBackupDirectory()
    */
    ItemBool *useBackupDirectoryItem()
    {
      return mUseBackupDirectoryItem;
    }

    /**
      Set Backup directory
    */
    static
    void setBackupDirectory( const QUrl & v )
    {
      if (!self()->isBackupDirectoryImmutable())
        self()->mBackupDirectory = v;
    }

    /**
      Get Backup directory
    */
    static
    QUrl backupDirectory()
    {
      return self()->mBackupDirectory;
    }

    /**
      Is Backup directory Immutable
    */
    static
    bool isBackupDirectoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackupDirectory" ) );
    }

    /**
      Get Item object corresponding to BackupDirectory()
    */
    ItemUrl *backupDirectoryItem()
    {
      return mBackupDirectoryItem;
    }

    /**
      Set Force fixed checksum block size:
    */
    static
    void setUseBlockSize( bool v )
    {
      if (!self()->isUseBlockSizeImmutable())
        self()->mUseBlockSize = v;
    }

    /**
      Get Force fixed checksum block size:
    */
    static
    bool useBlockSize()
    {
      return self()->mUseBlockSize;
    }

    /**
      Is Force fixed checksum block size: Immutable
    */
    static
    bool isUseBlockSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseBlockSize" ) );
    }

    /**
      Get Item object corresponding to UseBlockSize()
    */
    ItemBool *useBlockSizeItem()
    {
      return mUseBlockSizeItem;
    }

    /**
      Set The block size
    */
    static
    void setBlockSize( int v )
    {
      if (v < 0)
      {
        qDebug() << "setBlockSize: value " << v << " is less than the minimum value of 0";
        v = 0;
      }
      if (!self()->isBlockSizeImmutable())
        self()->mBlockSize = v;
    }

    /**
      Get The block size
    */
    static
    int blockSize()
    {
      return self()->mBlockSize;
    }

    /**
      Is The block size Immutable
    */
    static
    bool isBlockSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BlockSize" ) );
    }

    /**
      Get Item object corresponding to BlockSize()
    */
    ItemInt *blockSizeItem()
    {
      return mBlockSizeItem;
    }

    /**
      Set Set block/file checksum seed:
    */
    static
    void setUseChecksumSeed( bool v )
    {
      if (!self()->isUseChecksumSeedImmutable())
        self()->mUseChecksumSeed = v;
    }

    /**
      Get Set block/file checksum seed:
    */
    static
    bool useChecksumSeed()
    {
      return self()->mUseChecksumSeed;
    }

    /**
      Is Set block/file checksum seed: Immutable
    */
    static
    bool isUseChecksumSeedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseChecksumSeed" ) );
    }

    /**
      Get Item object corresponding to UseChecksumSeed()
    */
    ItemBool *useChecksumSeedItem()
    {
      return mUseChecksumSeedItem;
    }

    /**
      Set The value for the UseChecksumSeed config option
    */
    static
    void setChecksumSeed( int v )
    {
      if (v < 0)
      {
        qDebug() << "setChecksumSeed: value " << v << " is less than the minimum value of 0";
        v = 0;
      }
      if (!self()->isChecksumSeedImmutable())
        self()->mChecksumSeed = v;
    }

    /**
      Get The value for the UseChecksumSeed config option
    */
    static
    int checksumSeed()
    {
      return self()->mChecksumSeed;
    }

    /**
      Is The value for the UseChecksumSeed config option Immutable
    */
    static
    bool isChecksumSeedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ChecksumSeed" ) );
    }

    /**
      Get Item object corresponding to ChecksumSeed()
    */
    ItemInt *checksumSeedItem()
    {
      return mChecksumSeedItem;
    }

    /**
      Set Skip files based on checksum
    */
    static
    void setUseChecksum( bool v )
    {
      if (!self()->isUseChecksumImmutable())
        self()->mUseChecksum = v;
    }

    /**
      Get Skip files based on checksum
    */
    static
    bool useChecksum()
    {
      return self()->mUseChecksum;
    }

    /**
      Is Skip files based on checksum Immutable
    */
    static
    bool isUseChecksumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseChecksum" ) );
    }

    /**
      Get Item object corresponding to UseChecksum()
    */
    ItemBool *useChecksumItem()
    {
      return mUseChecksumItem;
    }

    /**
      Set Set bandwidth limit:
    */
    static
    void setUseBandwidthLimit( bool v )
    {
      if (!self()->isUseBandwidthLimitImmutable())
        self()->mUseBandwidthLimit = v;
    }

    /**
      Get Set bandwidth limit:
    */
    static
    bool useBandwidthLimit()
    {
      return self()->mUseBandwidthLimit;
    }

    /**
      Is Set bandwidth limit: Immutable
    */
    static
    bool isUseBandwidthLimitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseBandwidthLimit" ) );
    }

    /**
      Get Item object corresponding to UseBandwidthLimit()
    */
    ItemBool *useBandwidthLimitItem()
    {
      return mUseBandwidthLimitItem;
    }

    /**
      Set The value for the UseBandwidthLimit config option
    */
    static
    void setBandwidthLimit( int v )
    {
      if (v < 0)
      {
        qDebug() << "setBandwidthLimit: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isBandwidthLimitImmutable())
        self()->mBandwidthLimit = v;
    }

    /**
      Get The value for the UseBandwidthLimit config option
    */
    static
    int bandwidthLimit()
    {
      return self()->mBandwidthLimit;
    }

    /**
      Is The value for the UseBandwidthLimit config option Immutable
    */
    static
    bool isBandwidthLimitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BandwidthLimit" ) );
    }

    /**
      Get Item object corresponding to BandwidthLimit()
    */
    ItemInt *bandwidthLimitItem()
    {
      return mBandwidthLimitItem;
    }

    /**
      Set Use profiles
    */
    static
    void setUseProfiles( bool v )
    {
      if (!self()->isUseProfilesImmutable())
        self()->mUseProfiles = v;
    }

    /**
      Get Use profiles
    */
    static
    bool useProfiles()
    {
      return self()->mUseProfiles;
    }

    /**
      Is Use profiles Immutable
    */
    static
    bool isUseProfilesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseProfiles" ) );
    }

    /**
      Get Item object corresponding to UseProfiles()
    */
    ItemBool *useProfilesItem()
    {
      return mUseProfilesItem;
    }

    /**
      Set Profiles
    */
    static
    void setProfilesList( const QStringList & v )
    {
      if (!self()->isProfilesListImmutable())
        self()->mProfilesList = v;
    }

    /**
      Get Profiles
    */
    static
    QStringList profilesList()
    {
      return self()->mProfilesList;
    }

    /**
      Is Profiles Immutable
    */
    static
    bool isProfilesListImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProfilesList" ) );
    }

    /**
      Get Item object corresponding to ProfilesList()
    */
    ItemStringList *profilesListItem()
    {
      return mProfilesListItem;
    }

    /**
      Set Active profile
    */
    static
    void setActiveProfile( const QString & v )
    {
      if (!self()->isActiveProfileImmutable())
        self()->mActiveProfile = v;
    }

    /**
      Get Active profile
    */
    static
    QString activeProfile()
    {
      return self()->mActiveProfile;
    }

    /**
      Is Active profile Immutable
    */
    static
    bool isActiveProfileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ActiveProfile" ) );
    }

    /**
      Get Item object corresponding to ActiveProfile()
    */
    ItemString *activeProfileItem()
    {
      return mActiveProfileItem;
    }

  protected:
    Smb4KSettings();
    friend class Smb4KSettingsHelper;


    // UserInterface
    int mMainWindowTabOrientation;
    bool mShowCustomBookmarkLabel;
    bool mStartMainWindowDocked;
    bool mShowType;
    bool mShowIPAddress;
    bool mShowComment;
    bool mShowNetworkItemToolTip;
    bool mAutoExpandNetworkItems;
    bool mShowShareToolTip;
    int mSharesViewMode;
    int mSharesViewIconSizeIconView;
    int mSharesViewIconSizeListView;
    int mNetworkBrowserIconSize;

    // Network
    bool mUseWsDiscovery;
    bool mUseDnsServiceDiscovery;
    bool mUseClientProtocolVersions;
    int mMinimalClientProtocolVersion;
    int mMaximalClientProtocolVersion;
    bool mUseRemoteSmbPort;
    int mRemoteSmbPort;
    bool mLargeNetworkNeighborhood;
    bool mMasterBrowsersRequireAuth;
    bool mUseKerberos;
    bool mUseWinbindCCache;
    bool mUseEncryptionLevel;
    int mEncryptionLevel;
    bool mPreviewHiddenItems;
    bool mDetectPrinterShares;
    bool mDetectHiddenShares;
    bool mEnableWakeOnLAN;
    int mWakeOnLANWaitingTime;

    // Synchronization
    QUrl mRsyncPrefix;
    bool mArchiveMode;
    bool mRecurseIntoDirectories;
    bool mUpdateTarget;
    bool mUpdateInPlace;
    bool mRelativePathNames;
    bool mNoImpliedDirectories;
    bool mTransferDirectories;
    bool mCompressData;
    bool mUseCompressionLevel;
    int mCompressionLevel;
    bool mUseSkipCompression;
    QString mSkipCompression;
    bool mPreserveSymlinks;
    bool mTransformSymlinks;
    bool mTransformUnsafeSymlinks;
    bool mIgnoreUnsafeSymlinks;
    bool mMungeSymlinks;
    bool mPreserveHardLinks;
    bool mCopyDirectorySymlinks;
    bool mKeepDirectorySymlinks;
    bool mPreservePermissions;
    bool mPreserveACLs;
    bool mPreserveExtendedAttributes;
    bool mPreserveAccessTimes;
    bool mPreserveCreateTimes;
    bool mPreserveGroup;
    bool mPreserveOwner;
    bool mPreserveDevicesAndSpecials;
    bool mPreserveTimes;
    bool mOmitDirectoryTimes;
    bool mRemoveSourceFiles;
    bool mDeleteExtraneous;
    bool mDeleteBefore;
    bool mDeleteAfter;
    bool mDeleteDuring;
    bool mDeleteExcluded;
    bool mIgnoreErrors;
    bool mForceDirectoryDeletion;
    bool mUseMaximumDelete;
    int mMaximumDeleteValue;
    bool mUseMinimalTransferSize;
    int mMinimalTransferSize;
    bool mUseMaximalTransferSize;
    int mMaximalTransferSize;
    bool mKeepPartial;
    bool mUsePartialDirectory;
    QUrl mPartialDirectory;
    bool mUseCVSExclude;
    bool mUseExcludePattern;
    QString mExcludePattern;
    bool mUseExcludeFrom;
    QUrl mExcludeFrom;
    bool mUseIncludePattern;
    QString mIncludePattern;
    bool mUseIncludeFrom;
    QUrl mIncludeFrom;
    bool mUseCustomFilteringRules;
    QString mCustomFilteringRules;
    bool mUseFFilterRule;
    bool mUseFFFilterRule;
    bool mEfficientSparseFileHandling;
    bool mCopyFilesWhole;
    bool mOneFileSystem;
    bool mUpdateExisting;
    bool mIgnoreExisting;
    bool mDelayUpdates;
    bool mMakeBackups;
    bool mUseBackupSuffix;
    QString mBackupSuffix;
    bool mUseBackupDirectory;
    QUrl mBackupDirectory;
    bool mUseBlockSize;
    int mBlockSize;
    bool mUseChecksumSeed;
    int mChecksumSeed;
    bool mUseChecksum;
    bool mUseBandwidthLimit;
    int mBandwidthLimit;

    // Profiles
    bool mUseProfiles;
    QStringList mProfilesList;
    QString mActiveProfile;

  private:
    ItemEnum *mMainWindowTabOrientationItem;
    ItemBool *mShowCustomBookmarkLabelItem;
    ItemBool *mStartMainWindowDockedItem;
    ItemBool *mShowTypeItem;
    ItemBool *mShowIPAddressItem;
    ItemBool *mShowCommentItem;
    ItemBool *mShowNetworkItemToolTipItem;
    ItemBool *mAutoExpandNetworkItemsItem;
    ItemBool *mShowShareToolTipItem;
    ItemEnum *mSharesViewModeItem;
    ItemInt *mSharesViewIconSizeIconViewItem;
    ItemInt *mSharesViewIconSizeListViewItem;
    ItemInt *mNetworkBrowserIconSizeItem;
    ItemBool *mUseWsDiscoveryItem;
    ItemBool *mUseDnsServiceDiscoveryItem;
    ItemBool *mUseClientProtocolVersionsItem;
    ItemEnum *mMinimalClientProtocolVersionItem;
    ItemEnum *mMaximalClientProtocolVersionItem;
    ItemBool *mUseRemoteSmbPortItem;
    ItemInt *mRemoteSmbPortItem;
    ItemBool *mLargeNetworkNeighborhoodItem;
    ItemBool *mMasterBrowsersRequireAuthItem;
    ItemBool *mUseKerberosItem;
    ItemBool *mUseWinbindCCacheItem;
    ItemBool *mUseEncryptionLevelItem;
    ItemEnum *mEncryptionLevelItem;
    ItemBool *mPreviewHiddenItemsItem;
    ItemBool *mDetectPrinterSharesItem;
    ItemBool *mDetectHiddenSharesItem;
    ItemBool *mEnableWakeOnLANItem;
    ItemInt *mWakeOnLANWaitingTimeItem;
    ItemUrl *mRsyncPrefixItem;
    ItemBool *mArchiveModeItem;
    ItemBool *mRecurseIntoDirectoriesItem;
    ItemBool *mUpdateTargetItem;
    ItemBool *mUpdateInPlaceItem;
    ItemBool *mRelativePathNamesItem;
    ItemBool *mNoImpliedDirectoriesItem;
    ItemBool *mTransferDirectoriesItem;
    ItemBool *mCompressDataItem;
    ItemBool *mUseCompressionLevelItem;
    ItemInt *mCompressionLevelItem;
    ItemBool *mUseSkipCompressionItem;
    ItemString *mSkipCompressionItem;
    ItemBool *mPreserveSymlinksItem;
    ItemBool *mTransformSymlinksItem;
    ItemBool *mTransformUnsafeSymlinksItem;
    ItemBool *mIgnoreUnsafeSymlinksItem;
    ItemBool *mMungeSymlinksItem;
    ItemBool *mPreserveHardLinksItem;
    ItemBool *mCopyDirectorySymlinksItem;
    ItemBool *mKeepDirectorySymlinksItem;
    ItemBool *mPreservePermissionsItem;
    ItemBool *mPreserveACLsItem;
    ItemBool *mPreserveExtendedAttributesItem;
    ItemBool *mPreserveAccessTimesItem;
    ItemBool *mPreserveCreateTimesItem;
    ItemBool *mPreserveGroupItem;
    ItemBool *mPreserveOwnerItem;
    ItemBool *mPreserveDevicesAndSpecialsItem;
    ItemBool *mPreserveTimesItem;
    ItemBool *mOmitDirectoryTimesItem;
    ItemBool *mRemoveSourceFilesItem;
    ItemBool *mDeleteExtraneousItem;
    ItemBool *mDeleteBeforeItem;
    ItemBool *mDeleteAfterItem;
    ItemBool *mDeleteDuringItem;
    ItemBool *mDeleteExcludedItem;
    ItemBool *mIgnoreErrorsItem;
    ItemBool *mForceDirectoryDeletionItem;
    ItemBool *mUseMaximumDeleteItem;
    ItemInt *mMaximumDeleteValueItem;
    ItemBool *mUseMinimalTransferSizeItem;
    ItemInt *mMinimalTransferSizeItem;
    ItemBool *mUseMaximalTransferSizeItem;
    ItemInt *mMaximalTransferSizeItem;
    ItemBool *mKeepPartialItem;
    ItemBool *mUsePartialDirectoryItem;
    ItemUrl *mPartialDirectoryItem;
    ItemBool *mUseCVSExcludeItem;
    ItemBool *mUseExcludePatternItem;
    ItemString *mExcludePatternItem;
    ItemBool *mUseExcludeFromItem;
    ItemUrl *mExcludeFromItem;
    ItemBool *mUseIncludePatternItem;
    ItemString *mIncludePatternItem;
    ItemBool *mUseIncludeFromItem;
    ItemUrl *mIncludeFromItem;
    ItemBool *mUseCustomFilteringRulesItem;
    ItemString *mCustomFilteringRulesItem;
    ItemBool *mUseFFilterRuleItem;
    ItemBool *mUseFFFilterRuleItem;
    ItemBool *mEfficientSparseFileHandlingItem;
    ItemBool *mCopyFilesWholeItem;
    ItemBool *mOneFileSystemItem;
    ItemBool *mUpdateExistingItem;
    ItemBool *mIgnoreExistingItem;
    ItemBool *mDelayUpdatesItem;
    ItemBool *mMakeBackupsItem;
    ItemBool *mUseBackupSuffixItem;
    ItemString *mBackupSuffixItem;
    ItemBool *mUseBackupDirectoryItem;
    ItemUrl *mBackupDirectoryItem;
    ItemBool *mUseBlockSizeItem;
    ItemInt *mBlockSizeItem;
    ItemBool *mUseChecksumSeedItem;
    ItemInt *mChecksumSeedItem;
    ItemBool *mUseChecksumItem;
    ItemBool *mUseBandwidthLimitItem;
    ItemInt *mBandwidthLimitItem;
    ItemBool *mUseProfilesItem;
    ItemStringList *mProfilesListItem;
    ItemString *mActiveProfileItem;
};

#endif

