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

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

namespace Kleo {

class Settings : public KConfigSkeleton
{
  public:

    Settings( );
    ~Settings() override;

    /**
      Set Placeholder for CN
    */
    void setCnPlaceholder( const QString & v )
    {
      if (!isCnPlaceholderImmutable())
        mCnPlaceholder = v;
    }

    /**
      Get Placeholder for CN
    */
    QString cnPlaceholder() const
    {
      return mCnPlaceholder;
    }

    /**
      Is Placeholder for CN Immutable
    */
    bool isCnPlaceholderImmutable() const
    {
      return isImmutable( QStringLiteral( "cnPlaceholder" ) );
    }

    /**
      Set Prefill CN automatically
    */
    void setPrefillCN( bool v )
    {
      if (!isPrefillCNImmutable())
        mPrefillCN = v;
    }

    /**
      Get Prefill CN automatically
    */
    bool prefillCN() const
    {
      return mPrefillCN;
    }

    /**
      Is Prefill CN automatically Immutable
    */
    bool isPrefillCNImmutable() const
    {
      return isImmutable( QStringLiteral( "prefillCN" ) );
    }

    /**
      Set Hint for EMAIL
    */
    void setEmailPlaceholder( const QString & v )
    {
      if (!isEmailPlaceholderImmutable())
        mEmailPlaceholder = v;
    }

    /**
      Get Hint for EMAIL
    */
    QString emailPlaceholder() const
    {
      return mEmailPlaceholder;
    }

    /**
      Is Hint for EMAIL Immutable
    */
    bool isEmailPlaceholderImmutable() const
    {
      return isImmutable( QStringLiteral( "emailPlaceholder" ) );
    }

    /**
      Set Prefill EMAIL automatically
    */
    void setPrefillEmail( bool v )
    {
      if (!isPrefillEmailImmutable())
        mPrefillEmail = v;
    }

    /**
      Get Prefill EMAIL automatically
    */
    bool prefillEmail() const
    {
      return mPrefillEmail;
    }

    /**
      Is Prefill EMAIL automatically Immutable
    */
    bool isPrefillEmailImmutable() const
    {
      return isImmutable( QStringLiteral( "prefillEmail" ) );
    }

    /**
      Set Value of EMAIL
    */
    void setEmail( const QString & v )
    {
      if (!isEmailImmutable())
        mEmail = v;
    }

    /**
      Get Value of EMAIL
    */
    QString email() const
    {
      return mEmail;
    }

    /**
      Is Value of EMAIL Immutable
    */
    bool isEmailImmutable() const
    {
      return isImmutable( QStringLiteral( "email" ) );
    }

    /**
      Set Hint for NAME
    */
    void setNamePlaceholder( const QString & v )
    {
      if (!isNamePlaceholderImmutable())
        mNamePlaceholder = v;
    }

    /**
      Get Hint for NAME
    */
    QString namePlaceholder() const
    {
      return mNamePlaceholder;
    }

    /**
      Is Hint for NAME Immutable
    */
    bool isNamePlaceholderImmutable() const
    {
      return isImmutable( QStringLiteral( "namePlaceholder" ) );
    }

    /**
      Set Prefill NAME automatically
    */
    void setPrefillName( bool v )
    {
      if (!isPrefillNameImmutable())
        mPrefillName = v;
    }

    /**
      Get Prefill NAME automatically
    */
    bool prefillName() const
    {
      return mPrefillName;
    }

    /**
      Is Prefill NAME automatically Immutable
    */
    bool isPrefillNameImmutable() const
    {
      return isImmutable( QStringLiteral( "prefillName" ) );
    }

    /**
      Set Value of NAME
    */
    void setName( const QString & v )
    {
      if (!isNameImmutable())
        mName = v;
    }

    /**
      Get Value of NAME
    */
    QString name() const
    {
      return mName;
    }

    /**
      Is Value of NAME Immutable
    */
    bool isNameImmutable() const
    {
      return isImmutable( QStringLiteral( "name" ) );
    }

    /**
      Set Default validity period
    */
    void setValidityPeriodInDays( int v )
    {
      if (!isValidityPeriodInDaysImmutable())
        mValidityPeriodInDays = v;
    }

    /**
      Get Default validity period
    */
    int validityPeriodInDays() const
    {
      return mValidityPeriodInDays;
    }

    /**
      Is Default validity period Immutable
    */
    bool isValidityPeriodInDaysImmutable() const
    {
      return isImmutable( QStringLiteral( "ValidityPeriodInDays" ) );
    }

    /**
      Set Minimum validity period
    */
    void setValidityPeriodInDaysMin( int v )
    {
      if (!isValidityPeriodInDaysMinImmutable())
        mValidityPeriodInDaysMin = v;
    }

    /**
      Get Minimum validity period
    */
    int validityPeriodInDaysMin() const
    {
      return mValidityPeriodInDaysMin;
    }

    /**
      Is Minimum validity period Immutable
    */
    bool isValidityPeriodInDaysMinImmutable() const
    {
      return isImmutable( QStringLiteral( "ValidityPeriodInDaysMin" ) );
    }

    /**
      Set Maximum validity period
    */
    void setValidityPeriodInDaysMax( int v )
    {
      if (!isValidityPeriodInDaysMaxImmutable())
        mValidityPeriodInDaysMax = v;
    }

    /**
      Get Maximum validity period
    */
    int validityPeriodInDaysMax() const
    {
      return mValidityPeriodInDaysMax;
    }

    /**
      Is Maximum validity period Immutable
    */
    bool isValidityPeriodInDaysMaxImmutable() const
    {
      return isImmutable( QStringLiteral( "ValidityPeriodInDaysMax" ) );
    }

    /**
      Set Hide advanced settings
    */
    void setHideAdvanced( bool v )
    {
      if (!isHideAdvancedImmutable())
        mHideAdvanced = v;
    }

    /**
      Get Hide advanced settings
    */
    bool hideAdvanced() const
    {
      return mHideAdvanced;
    }

    /**
      Is Hide advanced settings Immutable
    */
    bool isHideAdvancedImmutable() const
    {
      return isImmutable( QStringLiteral( "HideAdvanced" ) );
    }

    /**
      Set Default certification validity
    */
    void setCertificationValidityInDays( int v )
    {
      if (!isCertificationValidityInDaysImmutable())
        mCertificationValidityInDays = v;
    }

    /**
      Get Default certification validity
    */
    int certificationValidityInDays() const
    {
      return mCertificationValidityInDays;
    }

    /**
      Is Default certification validity Immutable
    */
    bool isCertificationValidityInDaysImmutable() const
    {
      return isImmutable( QStringLiteral( "CertificationValidityInDays" ) );
    }

    /**
      Set Checksum program to use when creating checksum files
    */
    void setChecksumDefinitionId( const QString & v )
    {
      if (!isChecksumDefinitionIdImmutable())
        mChecksumDefinitionId = v;
    }

    /**
      Get Checksum program to use when creating checksum files
    */
    QString checksumDefinitionId() const
    {
      return mChecksumDefinitionId;
    }

    /**
      Is Checksum program to use when creating checksum files Immutable
    */
    bool isChecksumDefinitionIdImmutable() const
    {
      return isImmutable( QStringLiteral( "ChecksumDefinitionId" ) );
    }

    /**
      Set Show results after signing
    */
    void setShowResultsAfterSigningClipboard( bool v )
    {
      if (!isShowResultsAfterSigningClipboardImmutable())
        mShowResultsAfterSigningClipboard = v;
    }

    /**
      Get Show results after signing
    */
    bool showResultsAfterSigningClipboard() const
    {
      return mShowResultsAfterSigningClipboard;
    }

    /**
      Is Show results after signing Immutable
    */
    bool isShowResultsAfterSigningClipboardImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowResultsAfterSigningClipboard" ) );
    }

    /**
      Set Show results after encryption
    */
    void setShowResultsAfterEncryptingClipboard( bool v )
    {
      if (!isShowResultsAfterEncryptingClipboardImmutable())
        mShowResultsAfterEncryptingClipboard = v;
    }

    /**
      Get Show results after encryption
    */
    bool showResultsAfterEncryptingClipboard() const
    {
      return mShowResultsAfterEncryptingClipboard;
    }

    /**
      Is Show results after encryption Immutable
    */
    bool isShowResultsAfterEncryptingClipboardImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowResultsAfterEncryptingClipboard" ) );
    }

    /**
      Set Enable S/MIME
    */
    void setCmsEnabled( bool v )
    {
      if (!isCmsEnabledImmutable())
        mCmsEnabled = v;
    }

    /**
      Get Enable S/MIME
    */
    bool cmsEnabled() const
    {
      return mCmsEnabled;
    }

    /**
      Is Enable S/MIME Immutable
    */
    bool isCmsEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "cmsEnabled" ) );
    }

    /**
      Set Allow S/MIME certificate creation
    */
    void setCmsCertificateCreationAllowed( bool v )
    {
      if (!isCmsCertificateCreationAllowedImmutable())
        mCmsCertificateCreationAllowed = v;
    }

    /**
      Get Allow S/MIME certificate creation
    */
    bool cmsCertificateCreationAllowed() const
    {
      return mCmsCertificateCreationAllowed;
    }

    /**
      Is Allow S/MIME certificate creation Immutable
    */
    bool isCmsCertificateCreationAllowedImmutable() const
    {
      return isImmutable( QStringLiteral( "cmsCertificateCreationAllowed" ) );
    }

    /**
      Set Save generated CSR as PEM
    */
    void setSaveCSRAsPEM( bool v )
    {
      if (!isSaveCSRAsPEMImmutable())
        mSaveCSRAsPEM = v;
    }

    /**
      Get Save generated CSR as PEM
    */
    bool saveCSRAsPEM() const
    {
      return mSaveCSRAsPEM;
    }

    /**
      Is Save generated CSR as PEM Immutable
    */
    bool isSaveCSRAsPEMImmutable() const
    {
      return isImmutable( QStringLiteral( "SaveCSRAsPEM" ) );
    }

    /**
      Set Show appearance configuration
    */
    void setShowAppearanceConfiguration( bool v )
    {
      if (!isShowAppearanceConfigurationImmutable())
        mShowAppearanceConfiguration = v;
    }

    /**
      Get Show appearance configuration
    */
    bool showAppearanceConfiguration() const
    {
      return mShowAppearanceConfiguration;
    }

    /**
      Is Show appearance configuration Immutable
    */
    bool isShowAppearanceConfigurationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowAppearanceConfiguration" ) );
    }

    /**
      Set Show crypto operations configuration
    */
    void setShowCryptoOperationsConfiguration( bool v )
    {
      if (!isShowCryptoOperationsConfigurationImmutable())
        mShowCryptoOperationsConfiguration = v;
    }

    /**
      Get Show crypto operations configuration
    */
    bool showCryptoOperationsConfiguration() const
    {
      return mShowCryptoOperationsConfiguration;
    }

    /**
      Is Show crypto operations configuration Immutable
    */
    bool isShowCryptoOperationsConfigurationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowCryptoOperationsConfiguration" ) );
    }

    /**
      Set Show directory services configuration
    */
    void setShowDirectoryServicesConfiguration( bool v )
    {
      if (!isShowDirectoryServicesConfigurationImmutable())
        mShowDirectoryServicesConfiguration = v;
    }

    /**
      Get Show directory services configuration
    */
    bool showDirectoryServicesConfiguration() const
    {
      return mShowDirectoryServicesConfiguration;
    }

    /**
      Is Show directory services configuration Immutable
    */
    bool isShowDirectoryServicesConfigurationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowDirectoryServicesConfiguration" ) );
    }

    /**
      Set Show GnuPG system configuration
    */
    void setShowGnuPGSystemConfiguration( bool v )
    {
      if (!isShowGnuPGSystemConfigurationImmutable())
        mShowGnuPGSystemConfiguration = v;
    }

    /**
      Get Show GnuPG system configuration
    */
    bool showGnuPGSystemConfiguration() const
    {
      return mShowGnuPGSystemConfiguration;
    }

    /**
      Is Show GnuPG system configuration Immutable
    */
    bool isShowGnuPGSystemConfigurationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowGnuPGSystemConfiguration" ) );
    }

    /**
      Set Show smart cards configuration
    */
    void setShowSmartCardsConfiguration( bool v )
    {
      if (!isShowSmartCardsConfigurationImmutable())
        mShowSmartCardsConfiguration = v;
    }

    /**
      Get Show smart cards configuration
    */
    bool showSmartCardsConfiguration() const
    {
      return mShowSmartCardsConfiguration;
    }

    /**
      Is Show smart cards configuration Immutable
    */
    bool isShowSmartCardsConfigurationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowSmartCardsConfiguration" ) );
    }

    /**
      Set Show S/MIME validation configuration
    */
    void setShowSMimeValidationConfiguration( bool v )
    {
      if (!isShowSMimeValidationConfigurationImmutable())
        mShowSMimeValidationConfiguration = v;
    }

    /**
      Get Show S/MIME validation configuration
    */
    bool showSMimeValidationConfiguration() const
    {
      return mShowSMimeValidationConfiguration;
    }

    /**
      Is Show S/MIME validation configuration Immutable
    */
    bool isShowSMimeValidationConfigurationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowSMimeValidationConfiguration" ) );
    }

    /**
      Set DN-Attribute Order
    */
    void setAttributeOrder( const QStringList & v )
    {
      if (!isAttributeOrderImmutable())
        mAttributeOrder = v;
    }

    /**
      Get DN-Attribute Order
    */
    QStringList attributeOrder() const
    {
      return mAttributeOrder;
    }

    /**
      Is DN-Attribute Order Immutable
    */
    bool isAttributeOrderImmutable() const
    {
      return isImmutable( QStringLiteral( "AttributeOrder" ) );
    }

    /**
      Set Allow upload of public keys to keyservers
    */
    void setAllowPublicKeyUpload( bool v )
    {
      if (!isAllowPublicKeyUploadImmutable())
        mAllowPublicKeyUpload = v;
    }

    /**
      Get Allow upload of public keys to keyservers
    */
    bool allowPublicKeyUpload() const
    {
      return mAllowPublicKeyUpload;
    }

    /**
      Is Allow upload of public keys to keyservers Immutable
    */
    bool isAllowPublicKeyUploadImmutable() const
    {
      return isImmutable( QStringLiteral( "AllowPublicKeyUpload" ) );
    }

    /**
      Set Use pgp as the default extension for generated OpenPGP files
    */
    void setUsePGPFileExt( bool v )
    {
      if (!isUsePGPFileExtImmutable())
        mUsePGPFileExt = v;
    }

    /**
      Get Use pgp as the default extension for generated OpenPGP files
    */
    bool usePGPFileExt() const
    {
      return mUsePGPFileExt;
    }

    /**
      Is Use pgp as the default extension for generated OpenPGP files Immutable
    */
    bool isUsePGPFileExtImmutable() const
    {
      return isImmutable( QStringLiteral( "UsePGPFileExt" ) );
    }

    /**
      Set Automatically extract archives after decryption.
    */
    void setAutoExtractArchives( bool v )
    {
      if (!isAutoExtractArchivesImmutable())
        mAutoExtractArchives = v;
    }

    /**
      Get Automatically extract archives after decryption.
    */
    bool autoExtractArchives() const
    {
      return mAutoExtractArchives;
    }

    /**
      Is Automatically extract archives after decryption. Immutable
    */
    bool isAutoExtractArchivesImmutable() const
    {
      return isImmutable( QStringLiteral( "AutoExtractArchives" ) );
    }

    /**
      Set Use this command to create file archives.
    */
    void setArchiveCommand( const QString & v )
    {
      if (!isArchiveCommandImmutable())
        mArchiveCommand = v;
    }

    /**
      Get Use this command to create file archives.
    */
    QString archiveCommand() const
    {
      return mArchiveCommand;
    }

    /**
      Is Use this command to create file archives. Immutable
    */
    bool isArchiveCommandImmutable() const
    {
      return isImmutable( QStringLiteral( "ArchiveCommand" ) );
    }

    /**
      Set Create signed or encrypted files as text files.
    */
    void setAddASCIIArmor( bool v )
    {
      if (!isAddASCIIArmorImmutable())
        mAddASCIIArmor = v;
    }

    /**
      Get Create signed or encrypted files as text files.
    */
    bool addASCIIArmor() const
    {
      return mAddASCIIArmor;
    }

    /**
      Is Create signed or encrypted files as text files. Immutable
    */
    bool isAddASCIIArmorImmutable() const
    {
      return isImmutable( QStringLiteral( "AddASCIIArmor" ) );
    }

    /**
      Set Create temporary decrypted files in the folder of the encrypted file.
    */
    void setDontUseTmpDir( bool v )
    {
      if (!isDontUseTmpDirImmutable())
        mDontUseTmpDir = v;
    }

    /**
      Get Create temporary decrypted files in the folder of the encrypted file.
    */
    bool dontUseTmpDir() const
    {
      return mDontUseTmpDir;
    }

    /**
      Is Create temporary decrypted files in the folder of the encrypted file. Immutable
    */
    bool isDontUseTmpDirImmutable() const
    {
      return isImmutable( QStringLiteral( "DontUseTmpDir" ) );
    }

    /**
      Set Use symmetric encryption only.
    */
    void setSymmetricEncryptionOnly( bool v )
    {
      if (!isSymmetricEncryptionOnlyImmutable())
        mSymmetricEncryptionOnly = v;
    }

    /**
      Get Use symmetric encryption only.
    */
    bool symmetricEncryptionOnly() const
    {
      return mSymmetricEncryptionOnly;
    }

    /**
      Is Use symmetric encryption only. Immutable
    */
    bool isSymmetricEncryptionOnlyImmutable() const
    {
      return isImmutable( QStringLiteral( "SymmetricEncryptionOnly" ) );
    }

    /**
      Set Use public key encryption only.
    */
    void setPublicKeyEncryptionOnly( bool v )
    {
      if (!isPublicKeyEncryptionOnlyImmutable())
        mPublicKeyEncryptionOnly = v;
    }

    /**
      Get Use public key encryption only.
    */
    bool publicKeyEncryptionOnly() const
    {
      return mPublicKeyEncryptionOnly;
    }

    /**
      Is Use public key encryption only. Immutable
    */
    bool isPublicKeyEncryptionOnlyImmutable() const
    {
      return isImmutable( QStringLiteral( "PublicKeyEncryptionOnly" ) );
    }

    /**
      Set Enable Groups
    */
    void setGroupsEnabled( bool v )
    {
      if (!isGroupsEnabledImmutable())
        mGroupsEnabled = v;
    }

    /**
      Get Enable Groups
    */
    bool groupsEnabled() const
    {
      return mGroupsEnabled;
    }

    /**
      Is Enable Groups Immutable
    */
    bool isGroupsEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "GroupsEnabled" ) );
    }

    /**
      Set Retrieve signer keys after import
    */
    void setRetrieveSignerKeysAfterImport( bool v )
    {
      if (!isRetrieveSignerKeysAfterImportImmutable())
        mRetrieveSignerKeysAfterImport = v;
    }

    /**
      Get Retrieve signer keys after import
    */
    bool retrieveSignerKeysAfterImport() const
    {
      return mRetrieveSignerKeysAfterImport;
    }

    /**
      Is Retrieve signer keys after import Immutable
    */
    bool isRetrieveSignerKeysAfterImportImmutable() const
    {
      return isImmutable( QStringLiteral( "RetrieveSignerKeysAfterImport" ) );
    }

    /**
      Set Query certificate directories of providers for all user IDs
    */
    void setQueryWKDsForAllUserIDs( bool v )
    {
      if (!isQueryWKDsForAllUserIDsImmutable())
        mQueryWKDsForAllUserIDs = v;
    }

    /**
      Get Query certificate directories of providers for all user IDs
    */
    bool queryWKDsForAllUserIDs() const
    {
      return mQueryWKDsForAllUserIDs;
    }

    /**
      Is Query certificate directories of providers for all user IDs Immutable
    */
    bool isQueryWKDsForAllUserIDsImmutable() const
    {
      return isImmutable( QStringLiteral( "QueryWKDsForAllUserIDs" ) );
    }

    /**
      Set Notify about upcoming certificate expiration
    */
    void setShowExpiryNotifications( bool v )
    {
      if (!isShowExpiryNotificationsImmutable())
        mShowExpiryNotifications = v;
    }

    /**
      Get Notify about upcoming certificate expiration
    */
    bool showExpiryNotifications() const
    {
      return mShowExpiryNotifications;
    }

    /**
      Is Notify about upcoming certificate expiration Immutable
    */
    bool isShowExpiryNotificationsImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowExpiryNotifications" ) );
    }

    /**
      Set URL schemes to block
    */
    void setBlockedUrlSchemes( const QStringList & v )
    {
      if (!isBlockedUrlSchemesImmutable())
        mBlockedUrlSchemes = v;
    }

    /**
      Get URL schemes to block
    */
    QStringList blockedUrlSchemes() const
    {
      return mBlockedUrlSchemes;
    }

    /**
      Is URL schemes to block Immutable
    */
    bool isBlockedUrlSchemesImmutable() const
    {
      return isImmutable( QStringLiteral( "BlockedUrlSchemes" ) );
    }

    /**
      Set Always search smartcard certificates on keyserver
    */
    void setAlwaysSearchCardOnKeyserver( bool v )
    {
      if (!isAlwaysSearchCardOnKeyserverImmutable())
        mAlwaysSearchCardOnKeyserver = v;
    }

    /**
      Get Always search smartcard certificates on keyserver
    */
    bool alwaysSearchCardOnKeyserver() const
    {
      return mAlwaysSearchCardOnKeyserver;
    }

    /**
      Is Always search smartcard certificates on keyserver Immutable
    */
    bool isAlwaysSearchCardOnKeyserverImmutable() const
    {
      return isImmutable( QStringLiteral( "AlwaysSearchCardOnKeyserver" ) );
    }

    /**
      Set Try to load S/MIME certificates from PKCS#15 smartcards
    */
    void setAutoLoadP15Certs( bool v )
    {
      if (!isAutoLoadP15CertsImmutable())
        mAutoLoadP15Certs = v;
    }

    /**
      Get Try to load S/MIME certificates from PKCS#15 smartcards
    */
    bool autoLoadP15Certs() const
    {
      return mAutoLoadP15Certs;
    }

    /**
      Is Try to load S/MIME certificates from PKCS#15 smartcards Immutable
    */
    bool isAutoLoadP15CertsImmutable() const
    {
      return isImmutable( QStringLiteral( "autoLoadP15Certs" ) );
    }

    /**
      Set Certificate refresh interval (in hours). Zero (0) disables.
    */
    void setRefreshInterval( uint v )
    {

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

      if (!isRefreshIntervalImmutable())
        mRefreshInterval = v;
    }

    /**
      Get Certificate refresh interval (in hours). Zero (0) disables.
    */
    uint refreshInterval() const
    {
      return mRefreshInterval;
    }

    /**
      Is Certificate refresh interval (in hours). Zero (0) disables. Immutable
    */
    bool isRefreshIntervalImmutable() const
    {
      return isImmutable( QStringLiteral( "RefreshInterval" ) );
    }

    /**
      Set Disable profile settings
    */
    void setProfilesDisabled( bool v )
    {
      if (!isProfilesDisabledImmutable())
        mProfilesDisabled = v;
    }

    /**
      Get Disable profile settings
    */
    bool profilesDisabled() const
    {
      return mProfilesDisabled;
    }

    /**
      Is Disable profile settings Immutable
    */
    bool isProfilesDisabledImmutable() const
    {
      return isImmutable( QStringLiteral( "ProfilesDisabled" ) );
    }

    /**
      Set Allow custom debug commands
    */
    void setAllowCustomDebugCommands( bool v )
    {
      if (!isAllowCustomDebugCommandsImmutable())
        mAllowCustomDebugCommands = v;
    }

    /**
      Get Allow custom debug commands
    */
    bool allowCustomDebugCommands() const
    {
      return mAllowCustomDebugCommands;
    }

    /**
      Is Allow custom debug commands Immutable
    */
    bool isAllowCustomDebugCommandsImmutable() const
    {
      return isImmutable( QStringLiteral( "AllowCustomDebugCommands" ) );
    }

    /**
      Set Show results after signing and encrypting files
    */
    void setShowResultsAfterSignEncrypt( bool v )
    {
      if (!isShowResultsAfterSignEncryptImmutable())
        mShowResultsAfterSignEncrypt = v;
    }

    /**
      Get Show results after signing and encrypting files
    */
    bool showResultsAfterSignEncrypt() const
    {
      return mShowResultsAfterSignEncrypt;
    }

    /**
      Is Show results after signing and encrypting files Immutable
    */
    bool isShowResultsAfterSignEncryptImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowResultsAfterSignEncrypt" ) );
    }

    /**
      Set Use last-used values for the sign/encrypt configuration
    */
    void setRestoreSignEncryptValues( bool v )
    {
      if (!isRestoreSignEncryptValuesImmutable())
        mRestoreSignEncryptValues = v;
    }

    /**
      Get Use last-used values for the sign/encrypt configuration
    */
    bool restoreSignEncryptValues() const
    {
      return mRestoreSignEncryptValues;
    }

    /**
      Is Use last-used values for the sign/encrypt configuration Immutable
    */
    bool isRestoreSignEncryptValuesImmutable() const
    {
      return isImmutable( QStringLiteral( "RestoreSignEncryptValues" ) );
    }

    /**
      Set Show certificate validity
    */
    void setShowValidity( bool v )
    {
      if (!isShowValidityImmutable())
        mShowValidity = v;
    }

    /**
      Get Show certificate validity
    */
    bool showValidity() const
    {
      return mShowValidity;
    }

    /**
      Is Show certificate validity Immutable
    */
    bool isShowValidityImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowValidity" ) );
    }

    /**
      Set Show certificate owner information
    */
    void setShowOwnerInformation( bool v )
    {
      if (!isShowOwnerInformationImmutable())
        mShowOwnerInformation = v;
    }

    /**
      Get Show certificate owner information
    */
    bool showOwnerInformation() const
    {
      return mShowOwnerInformation;
    }

    /**
      Is Show certificate owner information Immutable
    */
    bool isShowOwnerInformationImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowOwnerInformation" ) );
    }

    /**
      Set Show certificate details
    */
    void setShowCertificateDetails( bool v )
    {
      if (!isShowCertificateDetailsImmutable())
        mShowCertificateDetails = v;
    }

    /**
      Get Show certificate details
    */
    bool showCertificateDetails() const
    {
      return mShowCertificateDetails;
    }

    /**
      Is Show certificate details Immutable
    */
    bool isShowCertificateDetailsImmutable() const
    {
      return isImmutable( QStringLiteral( "ShowCertificateDetails" ) );
    }

    /**
      Set Custom Welcome text
    */
    void setWelcomeText( const QString & v )
    {
      if (!isWelcomeTextImmutable())
        mWelcomeText = v;
    }

    /**
      Get Custom Welcome text
    */
    QString welcomeText() const
    {
      return mWelcomeText;
    }

    /**
      Is Custom Welcome text Immutable
    */
    bool isWelcomeTextImmutable() const
    {
      return isImmutable( QStringLiteral( "WelcomeText" ) );
    }

  protected:

    // CertificateCreationWizard
    QString mCnPlaceholder;
    bool mPrefillCN;
    QString mEmailPlaceholder;
    bool mPrefillEmail;
    QString mEmail;
    QString mNamePlaceholder;
    bool mPrefillName;
    QString mName;
    int mValidityPeriodInDays;
    int mValidityPeriodInDaysMin;
    int mValidityPeriodInDaysMax;
    bool mHideAdvanced;

    // Certification
    int mCertificationValidityInDays;

    // ChecksumOperations
    QString mChecksumDefinitionId;

    // Clipboard
    bool mShowResultsAfterSigningClipboard;
    bool mShowResultsAfterEncryptingClipboard;

    // CMS
    bool mCmsEnabled;
    bool mCmsCertificateCreationAllowed;
    bool mSaveCSRAsPEM;

    // ConfigurationDialog
    bool mShowAppearanceConfiguration;
    bool mShowCryptoOperationsConfiguration;
    bool mShowDirectoryServicesConfiguration;
    bool mShowGnuPGSystemConfiguration;
    bool mShowSmartCardsConfiguration;
    bool mShowSMimeValidationConfiguration;

    // DN
    QStringList mAttributeOrder;

    // Export
    bool mAllowPublicKeyUpload;

    // FileOperations
    bool mUsePGPFileExt;
    bool mAutoExtractArchives;
    QString mArchiveCommand;
    bool mAddASCIIArmor;
    bool mDontUseTmpDir;
    bool mSymmetricEncryptionOnly;
    bool mPublicKeyEncryptionOnly;

    // Groups
    bool mGroupsEnabled;

    // Import
    bool mRetrieveSignerKeysAfterImport;
    bool mQueryWKDsForAllUserIDs;

    // Notifications
    bool mShowExpiryNotifications;

    // Privacy
    QStringList mBlockedUrlSchemes;

    // Smartcard
    bool mAlwaysSearchCardOnKeyserver;
    bool mAutoLoadP15Certs;

    // SMime Validation
    uint mRefreshInterval;

    // General
    bool mProfilesDisabled;
    bool mAllowCustomDebugCommands;
    bool mShowResultsAfterSignEncrypt;
    bool mRestoreSignEncryptValues;

    // Tooltip
    bool mShowValidity;
    bool mShowOwnerInformation;
    bool mShowCertificateDetails;

    // Welcome
    QString mWelcomeText;
};

}

#endif

