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

#include "kmm_settings_export.h"
#include "kmymoneysettings_addon.h"

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

class KMM_SETTINGS_EXPORT KMyMoneySettings : public KConfigSkeleton
{
  public:
    enum ReconciliationHeader { Off, Last, All };
    enum PositionType { Day, Month, Year };

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

    /**
      Set Auto fill with previous transaction data
    */
    static
    void setAutoFillTransaction( int v )
    {
      if (!self()->isAutoFillTransactionImmutable())
        self()->mAutoFillTransaction = v;
    }

    /**
      Get Auto fill with previous transaction data
    */
    static
    int autoFillTransaction()
    {
      return self()->mAutoFillTransaction;
    }

    /**
      Is Auto fill with previous transaction data Immutable
    */
    static
    bool isAutoFillTransactionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoFillTransaction" ) );
    }

    /**
      Set Treat two transactions as identical, if amount differs by less than
    */
    static
    void setAutoFillDifference( int v )
    {
      if (!self()->isAutoFillDifferenceImmutable())
        self()->mAutoFillDifference = v;
    }

    /**
      Get Treat two transactions as identical, if amount differs by less than
    */
    static
    int autoFillDifference()
    {
      return self()->mAutoFillDifference;
    }

    /**
      Is Treat two transactions as identical, if amount differs by less than Immutable
    */
    static
    bool isAutoFillDifferenceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoFillDifference" ) );
    }

    /**
      Set When auto fill with previous transaction data use the memos
    */
    static
    void setAutoFillUseMemos( bool v )
    {
      if (!self()->isAutoFillUseMemosImmutable())
        self()->mAutoFillUseMemos = v;
    }

    /**
      Get When auto fill with previous transaction data use the memos
    */
    static
    bool autoFillUseMemos()
    {
      return self()->mAutoFillUseMemos;
    }

    /**
      Is When auto fill with previous transaction data use the memos Immutable
    */
    static
    bool isAutoFillUseMemosImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoFillUseMemos" ) );
    }

    /**
      Set Auto increment check number
    */
    static
    void setAutoIncCheckNumber( bool v )
    {
      if (!self()->isAutoIncCheckNumberImmutable())
        self()->mAutoIncCheckNumber = v;
    }

    /**
      Get Auto increment check number
    */
    static
    bool autoIncCheckNumber()
    {
      return self()->mAutoIncCheckNumber;
    }

    /**
      Is Auto increment check number Immutable
    */
    static
    bool isAutoIncCheckNumberImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoIncCheckNumber" ) );
    }

    /**
      Set Autosave file periodically
    */
    static
    void setAutoSaveFile( bool v )
    {
      if (!self()->isAutoSaveFileImmutable())
        self()->mAutoSaveFile = v;
    }

    /**
      Get Autosave file periodically
    */
    static
    bool autoSaveFile()
    {
      return self()->mAutoSaveFile;
    }

    /**
      Is Autosave file periodically Immutable
    */
    static
    bool isAutoSaveFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoSaveFile" ) );
    }

    /**
      Set Automatically find which transactions match the given reconciliation data
    */
    static
    void setAutoReconciliation( bool v )
    {
      if (!self()->isAutoReconciliationImmutable())
        self()->mAutoReconciliation = v;
    }

    /**
      Get Automatically find which transactions match the given reconciliation data
    */
    static
    bool autoReconciliation()
    {
      return self()->mAutoReconciliation;
    }

    /**
      Is Automatically find which transactions match the given reconciliation data Immutable
    */
    static
    bool isAutoReconciliationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoReconciliation" ) );
    }

    /**
      Set Number of backup files to keep
    */
    static
    void setAutoBackupCopies( int v )
    {
      if (v < 0)
      {
        qDebug() << "setAutoBackupCopies: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isAutoBackupCopiesImmutable())
        self()->mAutoBackupCopies = v;
    }

    /**
      Get Number of backup files to keep
    */
    static
    int autoBackupCopies()
    {
      return self()->mAutoBackupCopies;
    }

    /**
      Is Number of backup files to keep Immutable
    */
    static
    bool isAutoBackupCopiesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoBackupCopies" ) );
    }

    /**
      Set Character or string appended to backup filename
    */
    static
    void setBackupExtension( const QString & v )
    {
      if (!self()->isBackupExtensionImmutable())
        self()->mBackupExtension = v;
    }

    /**
      Get Character or string appended to backup filename
    */
    static
    QString backupExtension()
    {
      return self()->mBackupExtension;
    }

    /**
      Is Character or string appended to backup filename Immutable
    */
    static
    bool isBackupExtensionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackupExtension" ) );
    }

    /**
      Set Autosave interval in minutes
    */
    static
    void setAutoSavePeriod( int v )
    {
      if (v < 0)
      {
        qDebug() << "setAutoSavePeriod: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isAutoSavePeriodImmutable())
        self()->mAutoSavePeriod = v;
    }

    /**
      Get Autosave interval in minutes
    */
    static
    int autoSavePeriod()
    {
      return self()->mAutoSavePeriod;
    }

    /**
      Is Autosave interval in minutes Immutable
    */
    static
    bool isAutoSavePeriodImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoSavePeriod" ) );
    }

    /**
      Set Autosave file upon close
    */
    static
    void setAutoSaveOnClose( bool v )
    {
      if (!self()->isAutoSaveOnCloseImmutable())
        self()->mAutoSaveOnClose = v;
    }

    /**
      Get Autosave file upon close
    */
    static
    bool autoSaveOnClose()
    {
      return self()->mAutoSaveOnClose;
    }

    /**
      Is Autosave file upon close Immutable
    */
    static
    bool isAutoSaveOnCloseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoSaveOnClose" ) );
    }

    /**
      Set Check schedules upon startup
    */
    static
    void setCheckSchedule( bool v )
    {
      if (!self()->isCheckScheduleImmutable())
        self()->mCheckSchedule = v;
    }

    /**
      Get Check schedules upon startup
    */
    static
    bool checkSchedule()
    {
      return self()->mCheckSchedule;
    }

    /**
      Is Check schedules upon startup Immutable
    */
    static
    bool isCheckScheduleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CheckSchedule" ) );
    }

    /**
      Set Enter transactions this number of days in advance
    */
    static
    void setCheckSchedulePreview( int v )
    {
      if (v < 0)
      {
        qDebug() << "setCheckSchedulePreview: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isCheckSchedulePreviewImmutable())
        self()->mCheckSchedulePreview = v;
    }

    /**
      Get Enter transactions this number of days in advance
    */
    static
    int checkSchedulePreview()
    {
      return self()->mCheckSchedulePreview;
    }

    /**
      Is Enter transactions this number of days in advance Immutable
    */
    static
    bool isCheckSchedulePreviewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CheckSchedulePreview" ) );
    }

    /**
      Set Name of external calculator program
    */
    static
    void setExternalCalculator( const QString & v )
    {
      if (!self()->isExternalCalculatorImmutable())
        self()->mExternalCalculator = v;
    }

    /**
      Get Name of external calculator program
    */
    static
    QString externalCalculator()
    {
      return self()->mExternalCalculator;
    }

    /**
      Is Name of external calculator program Immutable
    */
    static
    bool isExternalCalculatorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExternalCalculator" ) );
    }

    /**
      Set Name of region used for non-processing days
    */
    static
    void setHolidayRegion( const QString & v )
    {
      if (!self()->isHolidayRegionImmutable())
        self()->mHolidayRegion = v;
    }

    /**
      Get Name of region used for non-processing days
    */
    static
    QString holidayRegion()
    {
      return self()->mHolidayRegion;
    }

    /**
      Is Name of region used for non-processing days Immutable
    */
    static
    bool isHolidayRegionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HolidayRegion" ) );
    }

    /**
      Set Number of days to preview schedules in ledger
    */
    static
    void setSchedulePreview( int v )
    {
      if (v < 0)
      {
        qDebug() << "setSchedulePreview: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isSchedulePreviewImmutable())
        self()->mSchedulePreview = v;
    }

    /**
      Get Number of days to preview schedules in ledger
    */
    static
    int schedulePreview()
    {
      return self()->mSchedulePreview;
    }

    /**
      Is Number of days to preview schedules in ledger Immutable
    */
    static
    bool isSchedulePreviewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SchedulePreview" ) );
    }

    /**
      Set Keep changes when selecting a different transaction/split
    */
    static
    void setFocusChangeIsEnter( bool v )
    {
      if (!self()->isFocusChangeIsEnterImmutable())
        self()->mFocusChangeIsEnter = v;
    }

    /**
      Get Keep changes when selecting a different transaction/split
    */
    static
    bool focusChangeIsEnter()
    {
      return self()->mFocusChangeIsEnter;
    }

    /**
      Is Keep changes when selecting a different transaction/split Immutable
    */
    static
    bool isFocusChangeIsEnterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FocusChangeIsEnter" ) );
    }

    /**
      Set Using the Enter key moves between the fields
    */
    static
    void setEnterMovesBetweenFields( bool v )
    {
      if (!self()->isEnterMovesBetweenFieldsImmutable())
        self()->mEnterMovesBetweenFields = v;
    }

    /**
      Get Using the Enter key moves between the fields
    */
    static
    bool enterMovesBetweenFields()
    {
      return self()->mEnterMovesBetweenFields;
    }

    /**
      Is Using the Enter key moves between the fields Immutable
    */
    static
    bool isEnterMovesBetweenFieldsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EnterMovesBetweenFields" ) );
    }

    /**
      Set Use the ledger lens
    */
    static
    void setLedgerLens( bool v )
    {
      if (!self()->isLedgerLensImmutable())
        self()->mLedgerLens = v;
    }

    /**
      Get Use the ledger lens
    */
    static
    bool ledgerLens()
    {
      return self()->mLedgerLens;
    }

    /**
      Is Use the ledger lens Immutable
    */
    static
    bool isLedgerLensImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LedgerLens" ) );
    }

    /**
      Set Update price history
    */
    static
    void setPriceHistoryUpdate( bool v )
    {
      if (!self()->isPriceHistoryUpdateImmutable())
        self()->mPriceHistoryUpdate = v;
    }

    /**
      Get Update price history
    */
    static
    bool priceHistoryUpdate()
    {
      return self()->mPriceHistoryUpdate;
    }

    /**
      Is Update price history Immutable
    */
    static
    bool isPriceHistoryUpdateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PriceHistoryUpdate" ) );
    }

    /**
      Set Show transaction form
    */
    static
    void setTransactionForm( bool v )
    {
      if (!self()->isTransactionFormImmutable())
        self()->mTransactionForm = v;
    }

    /**
      Get Show transaction form
    */
    static
    bool transactionForm()
    {
      return self()->mTransactionForm;
    }

    /**
      Is Show transaction form Immutable
    */
    static
    bool isTransactionFormImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TransactionForm" ) );
    }

    /**
      Set Start with last selected view or homepage
    */
    static
    void setStartLastViewSelected( int v )
    {
      if (!self()->isStartLastViewSelectedImmutable())
        self()->mStartLastViewSelected = v;
    }

    /**
      Get Start with last selected view or homepage
    */
    static
    int startLastViewSelected()
    {
      return self()->mStartLastViewSelected;
    }

    /**
      Is Start with last selected view or homepage Immutable
    */
    static
    bool isStartLastViewSelectedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartLastViewSelected" ) );
    }

    /**
      Set The last selected view
    */
    static
    void setLastViewSelected( int v )
    {
      if (!self()->isLastViewSelectedImmutable())
        self()->mLastViewSelected = v;
    }

    /**
      Get The last selected view
    */
    static
    int lastViewSelected()
    {
      return self()->mLastViewSelected;
    }

    /**
      Is The last selected view Immutable
    */
    static
    bool isLastViewSelectedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LastViewSelected" ) );
    }

    /**
      Set Use GPG to encrypt data file
    */
    static
    void setWriteDataEncrypted( bool v )
    {
      if (!self()->isWriteDataEncryptedImmutable())
        self()->mWriteDataEncrypted = v;
    }

    /**
      Get Use GPG to encrypt data file
    */
    static
    bool writeDataEncrypted()
    {
      return self()->mWriteDataEncrypted;
    }

    /**
      Is Use GPG to encrypt data file Immutable
    */
    static
    bool isWriteDataEncryptedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WriteDataEncrypted" ) );
    }

    /**
      Set Also encrypt against recover key
    */
    static
    void setEncryptRecover( bool v )
    {
      if (!self()->isEncryptRecoverImmutable())
        self()->mEncryptRecover = v;
    }

    /**
      Get Also encrypt against recover key
    */
    static
    bool encryptRecover()
    {
      return self()->mEncryptRecover;
    }

    /**
      Is Also encrypt against recover key Immutable
    */
    static
    bool isEncryptRecoverImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EncryptRecover" ) );
    }

    /**
      Set GPG User ID (deprecated)
    */
    static
    void setGpgRecipient( const QString & v )
    {
      if (!self()->isGpgRecipientImmutable())
        self()->mGpgRecipient = v;
    }

    /**
      Get GPG User ID (deprecated)
    */
    static
    QString gpgRecipient()
    {
      return self()->mGpgRecipient;
    }

    /**
      Is GPG User ID (deprecated) Immutable
    */
    static
    bool isGpgRecipientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GpgRecipient" ) );
    }

    /**
      Set GPG User ID
    */
    static
    void setGpgRecipientList( const QStringList & v )
    {
      if (!self()->isGpgRecipientListImmutable())
        self()->mGpgRecipientList = v;
    }

    /**
      Get GPG User ID
    */
    static
    QStringList gpgRecipientList()
    {
      return self()->mGpgRecipientList;
    }

    /**
      Is GPG User ID Immutable
    */
    static
    bool isGpgRecipientListImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GpgRecipientList" ) );
    }

    /**
      Set Run in expert (accountant) mode
    */
    static
    void setExpertMode( bool v )
    {
      if (!self()->isExpertModeImmutable())
        self()->mExpertMode = v;
    }

    /**
      Get Run in expert (accountant) mode
    */
    static
    bool expertMode()
    {
      return self()->mExpertMode;
    }

    /**
      Is Run in expert (accountant) mode Immutable
    */
    static
    bool isExpertModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExpertMode" ) );
    }

    /**
      Set Synchronize account in ledger and investment view
    */
    static
    void setSyncLedgerInvestment( bool v )
    {
      if (!self()->isSyncLedgerInvestmentImmutable())
        self()->mSyncLedgerInvestment = v;
    }

    /**
      Get Synchronize account in ledger and investment view
    */
    static
    bool syncLedgerInvestment()
    {
      return self()->mSyncLedgerInvestment;
    }

    /**
      Is Synchronize account in ledger and investment view Immutable
    */
    static
    bool isSyncLedgerInvestmentImmutable()
    {
      return self()->isImmutable( QStringLiteral( "syncLedgerInvestment" ) );
    }

    /**
      Set The type of the KMyMoney view
    */
    static
    void setViewType( int v )
    {
      if (!self()->isViewTypeImmutable())
        self()->mViewType = v;
    }

    /**
      Get The type of the KMyMoney view
    */
    static
    int viewType()
    {
      return self()->mViewType;
    }

    /**
      Is The type of the KMyMoney view Immutable
    */
    static
    bool isViewTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewType" ) );
    }

    /**
      Set First time switch to start new user wizard
    */
    static
    void setFirstTimeRun( bool v )
    {
      if (!self()->isFirstTimeRunImmutable())
        self()->mFirstTimeRun = v;
    }

    /**
      Get First time switch to start new user wizard
    */
    static
    bool firstTimeRun()
    {
      return self()->mFirstTimeRun;
    }

    /**
      Is First time switch to start new user wizard Immutable
    */
    static
    bool isFirstTimeRunImmutable()
    {
      return self()->isImmutable( QStringLiteral( "firstTimeRun" ) );
    }

    /**
      Set Match strings in auto-completion only from the first letter on. A substring behind the first letter is not found.
    */
    static
    void setStringMatchFromStart( bool v )
    {
      if (!self()->isStringMatchFromStartImmutable())
        self()->mStringMatchFromStart = v;
    }

    /**
      Get Match strings in auto-completion only from the first letter on. A substring behind the first letter is not found.
    */
    static
    bool stringMatchFromStart()
    {
      return self()->mStringMatchFromStart;
    }

    /**
      Is Match strings in auto-completion only from the first letter on. A substring behind the first letter is not found. Immutable
    */
    static
    bool isStringMatchFromStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stringMatchFromStart" ) );
    }

    /**
      Set Tab order of edit widgets in transaction form
    */
    static
    void setStdTransactionFormTabOrder( const QString & v )
    {
      if (!self()->isStdTransactionFormTabOrderImmutable())
        self()->mStdTransactionFormTabOrder = v;
    }

    /**
      Get Tab order of edit widgets in transaction form
    */
    static
    QString stdTransactionFormTabOrder()
    {
      return self()->mStdTransactionFormTabOrder;
    }

    /**
      Is Tab order of edit widgets in transaction form Immutable
    */
    static
    bool isStdTransactionFormTabOrderImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stdTransactionFormTabOrder" ) );
    }

    /**
      Set Tab order of edit widgets in register
    */
    static
    void setStdTransactionRegisterTabOrder( const QString & v )
    {
      if (!self()->isStdTransactionRegisterTabOrderImmutable())
        self()->mStdTransactionRegisterTabOrder = v;
    }

    /**
      Get Tab order of edit widgets in register
    */
    static
    QString stdTransactionRegisterTabOrder()
    {
      return self()->mStdTransactionRegisterTabOrder;
    }

    /**
      Is Tab order of edit widgets in register Immutable
    */
    static
    bool isStdTransactionRegisterTabOrderImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stdTransactionRegisterTabOrder" ) );
    }

    /**
      Set Order of items on homepage
    */
    static
    void setItemList( const QString & v )
    {
      if (!self()->isItemListImmutable())
        self()->mItemList = v;
    }

    /**
      Get Order of items on homepage
    */
    static
    QString itemList()
    {
      return self()->mItemList;
    }

    /**
      Is Order of items on homepage Immutable
    */
    static
    bool isItemListImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ItemList" ) );
    }

    /**
      Set Zoom factor used for home view HTML page
    */
    static
    void setZoomFactor( double v )
    {
      if (!self()->isZoomFactorImmutable())
        self()->mZoomFactor = v;
    }

    /**
      Get Zoom factor used for home view HTML page
    */
    static
    double zoomFactor()
    {
      return self()->mZoomFactor;
    }

    /**
      Is Zoom factor used for home view HTML page Immutable
    */
    static
    bool isZoomFactorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ZoomFactor" ) );
    }

    /**
      Set Remember (manually adjusted) zoom factor in home view on program end.
    */
    static
    void setRememberZoomFactor( bool v )
    {
      if (!self()->isRememberZoomFactorImmutable())
        self()->mRememberZoomFactor = v;
    }

    /**
      Get Remember (manually adjusted) zoom factor in home view on program end.
    */
    static
    bool rememberZoomFactor()
    {
      return self()->mRememberZoomFactor;
    }

    /**
      Is Remember (manually adjusted) zoom factor in home view on program end. Immutable
    */
    static
    bool isRememberZoomFactorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RememberZoomFactor" ) );
    }

    /**
      Set Show account limit information on the Homepage
    */
    static
    void setShowLimitInfo( bool v )
    {
      if (!self()->isShowLimitInfoImmutable())
        self()->mShowLimitInfo = v;
    }

    /**
      Get Show account limit information on the Homepage
    */
    static
    bool showLimitInfo()
    {
      return self()->mShowLimitInfo;
    }

    /**
      Is Show account limit information on the Homepage Immutable
    */
    static
    bool isShowLimitInfoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowLimitInfo" ) );
    }

    /**
      Set Show balance status on the Homepage for accounts where data imports include balance information.
    */
    static
    void setShowBalanceStatusOfOnlineAccounts( bool v )
    {
      if (!self()->isShowBalanceStatusOfOnlineAccountsImmutable())
        self()->mShowBalanceStatusOfOnlineAccounts = v;
    }

    /**
      Get Show balance status on the Homepage for accounts where data imports include balance information.
    */
    static
    bool showBalanceStatusOfOnlineAccounts()
    {
      return self()->mShowBalanceStatusOfOnlineAccounts;
    }

    /**
      Is Show balance status on the Homepage for accounts where data imports include balance information. Immutable
    */
    static
    bool isShowBalanceStatusOfOnlineAccountsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowBalanceStatusOfOnlineAccounts" ) );
    }

    /**
      Set Show number of not marked transactions per account on the Homepage [!M]
    */
    static
    void setShowCountOfUnmarkedTransactions( bool v )
    {
      if (!self()->isShowCountOfUnmarkedTransactionsImmutable())
        self()->mShowCountOfUnmarkedTransactions = v;
    }

    /**
      Get Show number of not marked transactions per account on the Homepage [!M]
    */
    static
    bool showCountOfUnmarkedTransactions()
    {
      return self()->mShowCountOfUnmarkedTransactions;
    }

    /**
      Is Show number of not marked transactions per account on the Homepage [!M] Immutable
    */
    static
    bool isShowCountOfUnmarkedTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowCountOfUnmarkedTransactions" ) );
    }

    /**
      Set Show number of cleared transactions per account on the Homepage [C]
    */
    static
    void setShowCountOfClearedTransactions( bool v )
    {
      if (!self()->isShowCountOfClearedTransactionsImmutable())
        self()->mShowCountOfClearedTransactions = v;
    }

    /**
      Get Show number of cleared transactions per account on the Homepage [C]
    */
    static
    bool showCountOfClearedTransactions()
    {
      return self()->mShowCountOfClearedTransactions;
    }

    /**
      Is Show number of cleared transactions per account on the Homepage [C] Immutable
    */
    static
    bool isShowCountOfClearedTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowCountOfClearedTransactions" ) );
    }

    /**
      Set Show number of not reconciled (not marked + cleared) transactions per account on the Homepage [!R]
    */
    static
    void setShowCountOfNotReconciledTransactions( bool v )
    {
      if (!self()->isShowCountOfNotReconciledTransactionsImmutable())
        self()->mShowCountOfNotReconciledTransactions = v;
    }

    /**
      Get Show number of not reconciled (not marked + cleared) transactions per account on the Homepage [!R]
    */
    static
    bool showCountOfNotReconciledTransactions()
    {
      return self()->mShowCountOfNotReconciledTransactions;
    }

    /**
      Is Show number of not reconciled (not marked + cleared) transactions per account on the Homepage [!R] Immutable
    */
    static
    bool isShowCountOfNotReconciledTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowCountOfNotReconciledTransactions" ) );
    }

    /**
      Set Show date of last reconciliation on the Homepage
    */
    static
    void setShowDateOfLastReconciliation( bool v )
    {
      if (!self()->isShowDateOfLastReconciliationImmutable())
        self()->mShowDateOfLastReconciliation = v;
    }

    /**
      Get Show date of last reconciliation on the Homepage
    */
    static
    bool showDateOfLastReconciliation()
    {
      return self()->mShowDateOfLastReconciliation;
    }

    /**
      Is Show date of last reconciliation on the Homepage Immutable
    */
    static
    bool isShowDateOfLastReconciliationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowDateOfLastReconciliation" ) );
    }

    /**
      Set Use custom colors
    */
    static
    void setUseCustomColors( bool v )
    {
      if (!self()->isUseCustomColorsImmutable())
        self()->mUseCustomColors = v;
    }

    /**
      Get Use custom colors
    */
    static
    bool useCustomColors()
    {
      return self()->mUseCustomColors;
    }

    /**
      Is Use custom colors Immutable
    */
    static
    bool isUseCustomColorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "useCustomColors" ) );
    }

    /**
      Set Background color for imported transactions
    */
    static
    void setTransactionImportedColor( const QColor & v )
    {
      if (!self()->isTransactionImportedColorImmutable())
        self()->mTransactionImportedColor = v;
    }

    /**
      Get Background color for imported transactions
    */
    static
    QColor transactionImportedColor()
    {
      return self()->mTransactionImportedColor;
    }

    /**
      Is Background color for imported transactions Immutable
    */
    static
    bool isTransactionImportedColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "transactionImportedColor" ) );
    }

    /**
      Set Text color for imported transactions
    */
    static
    void setTransactionImportedText( const QColor & v )
    {
      if (!self()->isTransactionImportedTextImmutable())
        self()->mTransactionImportedText = v;
    }

    /**
      Get Text color for imported transactions
    */
    static
    QColor transactionImportedText()
    {
      return self()->mTransactionImportedText;
    }

    /**
      Is Text color for imported transactions Immutable
    */
    static
    bool isTransactionImportedTextImmutable()
    {
      return self()->isImmutable( QStringLiteral( "transactionImportedText" ) );
    }

    /**
      Set Background color for matched transactions
    */
    static
    void setTransactionMatchedColor( const QColor & v )
    {
      if (!self()->isTransactionMatchedColorImmutable())
        self()->mTransactionMatchedColor = v;
    }

    /**
      Get Background color for matched transactions
    */
    static
    QColor transactionMatchedColor()
    {
      return self()->mTransactionMatchedColor;
    }

    /**
      Is Background color for matched transactions Immutable
    */
    static
    bool isTransactionMatchedColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "transactionMatchedColor" ) );
    }

    /**
      Set Text color for matched transactions
    */
    static
    void setTransactionMatchedText( const QColor & v )
    {
      if (!self()->isTransactionMatchedTextImmutable())
        self()->mTransactionMatchedText = v;
    }

    /**
      Get Text color for matched transactions
    */
    static
    QColor transactionMatchedText()
    {
      return self()->mTransactionMatchedText;
    }

    /**
      Is Text color for matched transactions Immutable
    */
    static
    bool isTransactionMatchedTextImmutable()
    {
      return self()->isImmutable( QStringLiteral( "transactionMatchedText" ) );
    }

    /**
      Set List color for erroneous transactions
    */
    static
    void setTransactionErroneousColor( const QColor & v )
    {
      if (!self()->isTransactionErroneousColorImmutable())
        self()->mTransactionErroneousColor = v;
    }

    /**
      Get List color for erroneous transactions
    */
    static
    QColor transactionErroneousColor()
    {
      return self()->mTransactionErroneousColor;
    }

    /**
      Is List color for erroneous transactions Immutable
    */
    static
    bool isTransactionErroneousColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "transactionErroneousColor" ) );
    }

    /**
      Set List color for missing conversion rate
    */
    static
    void setMissingConversionRateColor( const QColor & v )
    {
      if (!self()->isMissingConversionRateColorImmutable())
        self()->mMissingConversionRateColor = v;
    }

    /**
      Get List color for missing conversion rate
    */
    static
    QColor missingConversionRateColor()
    {
      return self()->mMissingConversionRateColor;
    }

    /**
      Is List color for missing conversion rate Immutable
    */
    static
    bool isMissingConversionRateColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "missingConversionRateColor" ) );
    }

    /**
      Set Background color for group marker
    */
    static
    void setGroupMarkerColor( const QColor & v )
    {
      if (!self()->isGroupMarkerColorImmutable())
        self()->mGroupMarkerColor = v;
    }

    /**
      Get Background color for group marker
    */
    static
    QColor groupMarkerColor()
    {
      return self()->mGroupMarkerColor;
    }

    /**
      Is Background color for group marker Immutable
    */
    static
    bool isGroupMarkerColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "groupMarkerColor" ) );
    }

    /**
      Set Text color for group marker
    */
    static
    void setGroupMarkerText( const QColor & v )
    {
      if (!self()->isGroupMarkerTextImmutable())
        self()->mGroupMarkerText = v;
    }

    /**
      Get Text color for group marker
    */
    static
    QColor groupMarkerText()
    {
      return self()->mGroupMarkerText;
    }

    /**
      Is Text color for group marker Immutable
    */
    static
    bool isGroupMarkerTextImmutable()
    {
      return self()->isImmutable( QStringLiteral( "groupMarkerText" ) );
    }

    /**
      Set Background color for required fields
    */
    static
    void setFieldRequiredColor( const QColor & v )
    {
      if (!self()->isFieldRequiredColorImmutable())
        self()->mFieldRequiredColor = v;
    }

    /**
      Get Background color for required fields
    */
    static
    QColor fieldRequiredColor()
    {
      return self()->mFieldRequiredColor;
    }

    /**
      Is Background color for required fields Immutable
    */
    static
    bool isFieldRequiredColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fieldRequiredColor" ) );
    }

    /**
      Set Hide unused categories
    */
    static
    void setHideUnusedCategory( bool v )
    {
      if (!self()->isHideUnusedCategoryImmutable())
        self()->mHideUnusedCategory = v;
    }

    /**
      Get Hide unused categories
    */
    static
    bool hideUnusedCategory()
    {
      return self()->mHideUnusedCategory;
    }

    /**
      Is Hide unused categories Immutable
    */
    static
    bool isHideUnusedCategoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideUnusedCategory" ) );
    }

    /**
      Set Show all accounts
    */
    static
    void setShowAllAccounts( bool v )
    {
      if (!self()->isShowAllAccountsImmutable())
        self()->mShowAllAccounts = v;
    }

    /**
      Get Show all accounts
    */
    static
    bool showAllAccounts()
    {
      return self()->mShowAllAccounts;
    }

    /**
      Is Show all accounts Immutable
    */
    static
    bool isShowAllAccountsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowAllAccounts" ) );
    }

    /**
      Set Show categories in the accounts view
    */
    static
    void setShowCategoriesInAccountsView( bool v )
    {
      if (!self()->isShowCategoriesInAccountsViewImmutable())
        self()->mShowCategoriesInAccountsView = v;
    }

    /**
      Get Show categories in the accounts view
    */
    static
    bool showCategoriesInAccountsView()
    {
      return self()->mShowCategoriesInAccountsView;
    }

    /**
      Is Show categories in the accounts view Immutable
    */
    static
    bool isShowCategoriesInAccountsViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowCategoriesInAccountsView" ) );
    }

    /**
      Set Hide zero balance equities
    */
    static
    void setHideZeroBalanceEquities( bool v )
    {
      if (!self()->isHideZeroBalanceEquitiesImmutable())
        self()->mHideZeroBalanceEquities = v;
    }

    /**
      Get Hide zero balance equities
    */
    static
    bool hideZeroBalanceEquities()
    {
      return self()->mHideZeroBalanceEquities;
    }

    /**
      Is Hide zero balance equities Immutable
    */
    static
    bool isHideZeroBalanceEquitiesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideZeroBalanceEquities" ) );
    }

    /**
      Set Hide zero balance accounts from Accounts
    */
    static
    void setHideZeroBalanceAccounts( bool v )
    {
      if (!self()->isHideZeroBalanceAccountsImmutable())
        self()->mHideZeroBalanceAccounts = v;
    }

    /**
      Get Hide zero balance accounts from Accounts
    */
    static
    bool hideZeroBalanceAccounts()
    {
      return self()->mHideZeroBalanceAccounts;
    }

    /**
      Is Hide zero balance accounts from Accounts Immutable
    */
    static
    bool isHideZeroBalanceAccountsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideZeroBalanceAccounts" ) );
    }

    /**
      Set Hide zero balance accounts from Home
    */
    static
    void setHideZeroBalanceAccountsHome( bool v )
    {
      if (!self()->isHideZeroBalanceAccountsHomeImmutable())
        self()->mHideZeroBalanceAccountsHome = v;
    }

    /**
      Get Hide zero balance accounts from Home
    */
    static
    bool hideZeroBalanceAccountsHome()
    {
      return self()->mHideZeroBalanceAccountsHome;
    }

    /**
      Is Hide zero balance accounts from Home Immutable
    */
    static
    bool isHideZeroBalanceAccountsHomeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideZeroBalanceAccountsHome" ) );
    }

    /**
      Set Hide finished schedules
    */
    static
    void setHideFinishedSchedules( bool v )
    {
      if (!self()->isHideFinishedSchedulesImmutable())
        self()->mHideFinishedSchedules = v;
    }

    /**
      Get Hide finished schedules
    */
    static
    bool hideFinishedSchedules()
    {
      return self()->mHideFinishedSchedules;
    }

    /**
      Is Hide finished schedules Immutable
    */
    static
    bool isHideFinishedSchedulesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideFinishedSchedules" ) );
    }

    /**
      Set Hide reconciled transactions
    */
    static
    void setHideReconciledTransactions( bool v )
    {
      if (!self()->isHideReconciledTransactionsImmutable())
        self()->mHideReconciledTransactions = v;
    }

    /**
      Get Hide reconciled transactions
    */
    static
    bool hideReconciledTransactions()
    {
      return self()->mHideReconciledTransactions;
    }

    /**
      Is Hide reconciled transactions Immutable
    */
    static
    bool isHideReconciledTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideReconciledTransactions" ) );
    }

    /**
      Set Show all register entries in full detail
    */
    static
    void setShowRegisterDetailed( bool v )
    {
      if (!self()->isShowRegisterDetailedImmutable())
        self()->mShowRegisterDetailed = v;
    }

    /**
      Get Show all register entries in full detail
    */
    static
    bool showRegisterDetailed()
    {
      return self()->mShowRegisterDetailed;
    }

    /**
      Is Show all register entries in full detail Immutable
    */
    static
    bool isShowRegisterDetailedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowRegisterDetailed" ) );
    }

    /**
      Set Show all split details in register
    */
    static
    void setShowAllSplits( bool v )
    {
      if (!self()->isShowAllSplitsImmutable())
        self()->mShowAllSplits = v;
    }

    /**
      Get Show all split details in register
    */
    static
    bool showAllSplits()
    {
      return self()->mShowAllSplits;
    }

    /**
      Is Show all split details in register Immutable
    */
    static
    bool isShowAllSplitsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowAllSplits" ) );
    }

    /**
      Set Show schedules with planned date
    */
    static
    void setShowPlannedScheduleDates( bool v )
    {
      if (!self()->isShowPlannedScheduleDatesImmutable())
        self()->mShowPlannedScheduleDates = v;
    }

    /**
      Get Show schedules with planned date
    */
    static
    bool showPlannedScheduleDates()
    {
      return self()->mShowPlannedScheduleDates;
    }

    /**
      Is Show schedules with planned date Immutable
    */
    static
    bool isShowPlannedScheduleDatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowPlannedScheduleDates" ) );
    }

    /**
      Set Show a grid in the register
    */
    static
    void setShowGrid( bool v )
    {
      if (!self()->isShowGridImmutable())
        self()->mShowGrid = v;
    }

    /**
      Get Show a grid in the register
    */
    static
    bool showGrid()
    {
      return self()->mShowGrid;
    }

    /**
      Is Show a grid in the register Immutable
    */
    static
    bool isShowGridImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowGrid" ) );
    }

    /**
      Set Show the filter widget when an account is opened
    */
    static
    void setShowLedgerFilter( bool v )
    {
      if (!self()->isShowLedgerFilterImmutable())
        self()->mShowLedgerFilter = v;
    }

    /**
      Get Show the filter widget when an account is opened
    */
    static
    bool showLedgerFilter()
    {
      return self()->mShowLedgerFilter;
    }

    /**
      Is Show the filter widget when an account is opened Immutable
    */
    static
    bool isShowLedgerFilterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowLedgerFilter" ) );
    }

    /**
      Set Show fancy group markers
    */
    static
    void setShowFancyMarker( bool v )
    {
      if (!self()->isShowFancyMarkerImmutable())
        self()->mShowFancyMarker = v;
    }

    /**
      Get Show fancy group markers
    */
    static
    bool showFancyMarker()
    {
      return self()->mShowFancyMarker;
    }

    /**
      Is Show fancy group markers Immutable
    */
    static
    bool isShowFancyMarkerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowFancyMarker" ) );
    }

    /**
      Set Show fancy markers for previous and current fiscal year
    */
    static
    void setShowFiscalMarker( bool v )
    {
      if (!self()->isShowFiscalMarkerImmutable())
        self()->mShowFiscalMarker = v;
    }

    /**
      Get Show fancy markers for previous and current fiscal year
    */
    static
    bool showFiscalMarker()
    {
      return self()->mShowFiscalMarker;
    }

    /**
      Is Show fancy markers for previous and current fiscal year Immutable
    */
    static
    bool isShowFiscalMarkerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowFiscalMarker" ) );
    }

    /**
      Set Show reconciliation entries with date and balance
    */
    static
    void setShowReconciliationMarker( ReconciliationHeader v )
    {
      if (!self()->isShowReconciliationMarkerImmutable())
        self()->mShowReconciliationMarker = v;
    }

    /**
      Get Show reconciliation entries with date and balance
    */
    static
    ReconciliationHeader showReconciliationMarker()
    {
      return static_cast<ReconciliationHeader>(self()->mShowReconciliationMarker);
    }

    /**
      Is Show reconciliation entries with date and balance Immutable
    */
    static
    bool isShowReconciliationMarkerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowReconciliationMarker" ) );
    }

    /**
      Set Starting month of the fiscal year
    */
    static
    void setFiscalYearBegin( int v )
    {
      if (v < 0)
      {
        qDebug() << "setFiscalYearBegin: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isFiscalYearBeginImmutable())
        self()->mFiscalYearBegin = v;
    }

    /**
      Get Starting month of the fiscal year
    */
    static
    int fiscalYearBegin()
    {
      return self()->mFiscalYearBegin;
    }

    /**
      Is Starting month of the fiscal year Immutable
    */
    static
    bool isFiscalYearBeginImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FiscalYearBegin" ) );
    }

    /**
      Set Starting day of the fiscal year
    */
    static
    void setFiscalYearBeginDay( int v )
    {
      if (v < 1)
      {
        qDebug() << "setFiscalYearBeginDay: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

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

      if (!self()->isFiscalYearBeginDayImmutable())
        self()->mFiscalYearBeginDay = v;
    }

    /**
      Get Starting day of the fiscal year
    */
    static
    int fiscalYearBeginDay()
    {
      return self()->mFiscalYearBeginDay;
    }

    /**
      Is Starting day of the fiscal year Immutable
    */
    static
    bool isFiscalYearBeginDayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FiscalYearBeginDay" ) );
    }

    /**
      Set Start date
    */
    static
    void setStartDate( const QDateTime & v )
    {
      if (!self()->isStartDateImmutable())
        self()->mStartDate = v;
    }

    /**
      Get Start date
    */
    static
    QDateTime startDate()
    {
      return self()->mStartDate;
    }

    /**
      Is Start date Immutable
    */
    static
    bool isStartDateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartDate" ) );
    }

    /**
      Set Log file path
    */
    static
    void setLogPath( const QString & v )
    {
      if (!self()->isLogPathImmutable())
        self()->mLogPath = v;
    }

    /**
      Get Log file path
    */
    static
    QString logPath()
    {
      return self()->mLogPath;
    }

    /**
      Is Log file path Immutable
    */
    static
    bool isLogPathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "logPath" ) );
    }

    /**
      Set Log imported statements
    */
    static
    void setLogImportedStatements( bool v )
    {
      if (!self()->isLogImportedStatementsImmutable())
        self()->mLogImportedStatements = v;
    }

    /**
      Get Log imported statements
    */
    static
    bool logImportedStatements()
    {
      return self()->mLogImportedStatements;
    }

    /**
      Is Log imported statements Immutable
    */
    static
    bool isLogImportedStatementsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "logImportedStatements" ) );
    }

    /**
      Set Log OFX transactions
    */
    static
    void setLogOfxTransactions( bool v )
    {
      if (!self()->isLogOfxTransactionsImmutable())
        self()->mLogOfxTransactions = v;
    }

    /**
      Get Log OFX transactions
    */
    static
    bool logOfxTransactions()
    {
      return self()->mLogOfxTransactions;
    }

    /**
      Is Log OFX transactions Immutable
    */
    static
    bool isLogOfxTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "logOfxTransactions" ) );
    }

    /**
      Set Use system font
    */
    static
    void setUseSystemFont( bool v )
    {
      if (!self()->isUseSystemFontImmutable())
        self()->mUseSystemFont = v;
    }

    /**
      Get Use system font
    */
    static
    bool useSystemFont()
    {
      return self()->mUseSystemFont;
    }

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

    /**
      Set Cell font
    */
    static
    void setListCellFont( const QFont & v )
    {
      if (!self()->isListCellFontImmutable())
        self()->mListCellFont = v;
    }

    /**
      Get Cell font
    */
    static
    QFont listCellFont()
    {
      return self()->mListCellFont;
    }

    /**
      Is Cell font Immutable
    */
    static
    bool isListCellFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "listCellFont" ) );
    }

    /**
      Set Header font
    */
    static
    void setListHeaderFont( const QFont & v )
    {
      if (!self()->isListHeaderFontImmutable())
        self()->mListHeaderFont = v;
    }

    /**
      Get Header font
    */
    static
    QFont listHeaderFont()
    {
      return self()->mListHeaderFont;
    }

    /**
      Is Header font Immutable
    */
    static
    bool isListHeaderFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "listHeaderFont" ) );
    }

    /**
      Set Icon theme
    */
    static
    void setIconsTheme( const QString & v )
    {
      if (!self()->isIconsThemeImmutable())
        self()->mIconsTheme = v;
    }

    /**
      Get Icon theme
    */
    static
    QString iconsTheme()
    {
      return self()->mIconsTheme;
    }

    /**
      Is Icon theme Immutable
    */
    static
    bool isIconsThemeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IconsTheme" ) );
    }

    /**
      Set Sort order of register in normal view
    */
    static
    void setSortNormalView( const QString & v )
    {
      if (!self()->isSortNormalViewImmutable())
        self()->mSortNormalView = v;
    }

    /**
      Get Sort order of register in normal view
    */
    static
    QString sortNormalView()
    {
      return self()->mSortNormalView;
    }

    /**
      Is Sort order of register in normal view Immutable
    */
    static
    bool isSortNormalViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "sortNormalView" ) );
    }

    /**
      Set Sort order of register in normal view
    */
    static
    void setSortReconcileView( const QString & v )
    {
      if (!self()->isSortReconcileViewImmutable())
        self()->mSortReconcileView = v;
    }

    /**
      Get Sort order of register in normal view
    */
    static
    QString sortReconcileView()
    {
      return self()->mSortReconcileView;
    }

    /**
      Is Sort order of register in normal view Immutable
    */
    static
    bool isSortReconcileViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "sortReconcileView" ) );
    }

    /**
      Set Sort order of register in search dialog
    */
    static
    void setSortSearchView( const QString & v )
    {
      if (!self()->isSortSearchViewImmutable())
        self()->mSortSearchView = v;
    }

    /**
      Get Sort order of register in search dialog
    */
    static
    QString sortSearchView()
    {
      return self()->mSortSearchView;
    }

    /**
      Is Sort order of register in search dialog Immutable
    */
    static
    bool isSortSearchViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "sortSearchView" ) );
    }

    /**
      Set Initial cursor position within the date field
    */
    static
    void setInitialDateFieldCursorPosition( PositionType v )
    {
      if (!self()->isInitialDateFieldCursorPositionImmutable())
        self()->mInitialDateFieldCursorPosition = v;
    }

    /**
      Get Initial cursor position within the date field
    */
    static
    PositionType initialDateFieldCursorPosition()
    {
      return static_cast<PositionType>(self()->mInitialDateFieldCursorPosition);
    }

    /**
      Is Initial cursor position within the date field Immutable
    */
    static
    bool isInitialDateFieldCursorPositionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "initialDateFieldCursorPosition" ) );
    }

    /**
      Set Default reconciliation state for transactions entered during reconciliation
    */
    static
    void setDefaultReconciliationState( int v )
    {
      if (!self()->isDefaultReconciliationStateImmutable())
        self()->mDefaultReconciliationState = v;
    }

    /**
      Get Default reconciliation state for transactions entered during reconciliation
    */
    static
    int defaultReconciliationState()
    {
      return self()->mDefaultReconciliationState;
    }

    /**
      Is Default reconciliation state for transactions entered during reconciliation Immutable
    */
    static
    bool isDefaultReconciliationStateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultReconciliationState" ) );
    }

    /**
      Set Number of days (plus/minus) to search for matching transactions
    */
    static
    void setMatchInterval( int v )
    {
      if (!self()->isMatchIntervalImmutable())
        self()->mMatchInterval = v;
    }

    /**
      Get Number of days (plus/minus) to search for matching transactions
    */
    static
    int matchInterval()
    {
      return self()->mMatchInterval;
    }

    /**
      Is Number of days (plus/minus) to search for matching transactions Immutable
    */
    static
    bool isMatchIntervalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "matchInterval" ) );
    }

    /**
      Set During import, ask for a new payee's default category
    */
    static
    void setAskForPayeeCategory( bool v )
    {
      if (!self()->isAskForPayeeCategoryImmutable())
        self()->mAskForPayeeCategory = v;
    }

    /**
      Get During import, ask for a new payee's default category
    */
    static
    bool askForPayeeCategory()
    {
      return self()->mAskForPayeeCategory;
    }

    /**
      Is During import, ask for a new payee's default category Immutable
    */
    static
    bool isAskForPayeeCategoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "askForPayeeCategory" ) );
    }

    /**
      Set Post date last entered by the user
    */
    static
    void setLastUsedPostDate( const QDateTime & v )
    {
      if (!self()->isLastUsedPostDateImmutable())
        self()->mLastUsedPostDate = v;
    }

    /**
      Get Post date last entered by the user
    */
    static
    QDateTime lastUsedPostDate()
    {
      return self()->mLastUsedPostDate;
    }

    /**
      Is Post date last entered by the user Immutable
    */
    static
    bool isLastUsedPostDateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lastUsedPostDate" ) );
    }

    /**
      Set additional names for cash account
    */
    static
    void setQifCash( const QString & v )
    {
      if (!self()->isQifCashImmutable())
        self()->mQifCash = v;
    }

    /**
      Get additional names for cash account
    */
    static
    QString qifCash()
    {
      return self()->mQifCash;
    }

    /**
      Is additional names for cash account Immutable
    */
    static
    bool isQifCashImmutable()
    {
      return self()->isImmutable( QStringLiteral( "qifCash" ) );
    }

    /**
      Set additional names for checking account
    */
    static
    void setQifBank( const QString & v )
    {
      if (!self()->isQifBankImmutable())
        self()->mQifBank = v;
    }

    /**
      Get additional names for checking account
    */
    static
    QString qifBank()
    {
      return self()->mQifBank;
    }

    /**
      Is additional names for checking account Immutable
    */
    static
    bool isQifBankImmutable()
    {
      return self()->isImmutable( QStringLiteral( "qifBank" ) );
    }

    /**
      Set additional names for credit card account
    */
    static
    void setQifCreditCard( const QString & v )
    {
      if (!self()->isQifCreditCardImmutable())
        self()->mQifCreditCard = v;
    }

    /**
      Get additional names for credit card account
    */
    static
    QString qifCreditCard()
    {
      return self()->mQifCreditCard;
    }

    /**
      Is additional names for credit card account Immutable
    */
    static
    bool isQifCreditCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "qifCreditCard" ) );
    }

    /**
      Set additional names for asset account
    */
    static
    void setQifAsset( const QString & v )
    {
      if (!self()->isQifAssetImmutable())
        self()->mQifAsset = v;
    }

    /**
      Get additional names for asset account
    */
    static
    QString qifAsset()
    {
      return self()->mQifAsset;
    }

    /**
      Is additional names for asset account Immutable
    */
    static
    bool isQifAssetImmutable()
    {
      return self()->isImmutable( QStringLiteral( "qifAsset" ) );
    }

    /**
      Set additional names for opening balance payee
    */
    static
    void setQifOpeningBalance( const QString & v )
    {
      if (!self()->isQifOpeningBalanceImmutable())
        self()->mQifOpeningBalance = v;
    }

    /**
      Get additional names for opening balance payee
    */
    static
    QString qifOpeningBalance()
    {
      return self()->mQifOpeningBalance;
    }

    /**
      Is additional names for opening balance payee Immutable
    */
    static
    bool isQifOpeningBalanceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "qifOpeningBalance" ) );
    }

    /**
      Set additional names for invoice accounts
    */
    static
    void setQifInvoice( const QString & v )
    {
      if (!self()->isQifInvoiceImmutable())
        self()->mQifInvoice = v;
    }

    /**
      Get additional names for invoice accounts
    */
    static
    QString qifInvoice()
    {
      return self()->mQifInvoice;
    }

    /**
      Is additional names for invoice accounts Immutable
    */
    static
    bool isQifInvoiceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "qifInvoice" ) );
    }

    /**
      Set Show accounts view expanded when loaded
    */
    static
    void setShowAccountsExpanded( bool v )
    {
      if (!self()->isShowAccountsExpandedImmutable())
        self()->mShowAccountsExpanded = v;
    }

    /**
      Get Show accounts view expanded when loaded
    */
    static
    bool showAccountsExpanded()
    {
      return self()->mShowAccountsExpanded;
    }

    /**
      Is Show accounts view expanded when loaded Immutable
    */
    static
    bool isShowAccountsExpandedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showAccountsExpanded" ) );
    }

    /**
      Set Maximum quantity of legend items to display on charts
    */
    static
    void setMaximumLegendItems( int v )
    {
      if (v < 0)
      {
        qDebug() << "setMaximumLegendItems: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isMaximumLegendItemsImmutable())
        self()->mMaximumLegendItems = v;
    }

    /**
      Get Maximum quantity of legend items to display on charts
    */
    static
    int maximumLegendItems()
    {
      return self()->mMaximumLegendItems;
    }

    /**
      Is Maximum quantity of legend items to display on charts Immutable
    */
    static
    bool isMaximumLegendItemsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaximumLegendItems" ) );
    }

    /**
      Set Line width for diagrams, in pixels
    */
    static
    void setLineWidth( int v )
    {
      if (v < 0)
      {
        qDebug() << "setLineWidth: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isLineWidthImmutable())
        self()->mLineWidth = v;
    }

    /**
      Get Line width for diagrams, in pixels
    */
    static
    int lineWidth()
    {
      return self()->mLineWidth;
    }

    /**
      Is Line width for diagrams, in pixels Immutable
    */
    static
    bool isLineWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LineWidth" ) );
    }

    /**
      Set The palette used to render charts
    */
    static
    void setChartsPalette( int v )
    {
      if (v < 0)
      {
        qDebug() << "setChartsPalette: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isChartsPaletteImmutable())
        self()->mChartsPalette = v;
    }

    /**
      Get The palette used to render charts
    */
    static
    int chartsPalette()
    {
      return self()->mChartsPalette;
    }

    /**
      Is The palette used to render charts Immutable
    */
    static
    bool isChartsPaletteImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ChartsPalette" ) );
    }

    /**
      Set Name of default CSS file
    */
    static
    void setCssFileDefault( const QString & v )
    {
      if (!self()->isCssFileDefaultImmutable())
        self()->mCssFileDefault = v;
    }

    /**
      Get Name of default CSS file
    */
    static
    QString cssFileDefault()
    {
      return self()->mCssFileDefault;
    }

    /**
      Is Name of default CSS file Immutable
    */
    static
    bool isCssFileDefaultImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CssFileDefault" ) );
    }

    /**
      Set Method to calculate forecast
    */
    static
    void setForecastMethod( int v )
    {
      if (!self()->isForecastMethodImmutable())
        self()->mForecastMethod = v;
    }

    /**
      Get Method to calculate forecast
    */
    static
    int forecastMethod()
    {
      return self()->mForecastMethod;
    }

    /**
      Is Method to calculate forecast Immutable
    */
    static
    bool isForecastMethodImmutable()
    {
      return self()->isImmutable( QStringLiteral( "forecastMethod" ) );
    }

    /**
      Set Days to forecast
    */
    static
    void setForecastDays( qint64 v )
    {
      if (v < 1)
      {
        qDebug() << "setForecastDays: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

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

      if (!self()->isForecastDaysImmutable())
        self()->mForecastDays = v;
    }

    /**
      Get Days to forecast
    */
    static
    qint64 forecastDays()
    {
      return self()->mForecastDays;
    }

    /**
      Is Days to forecast Immutable
    */
    static
    bool isForecastDaysImmutable()
    {
      return self()->isImmutable( QStringLiteral( "forecastDays" ) );
    }

    /**
      Set Days of normal account cycle
    */
    static
    void setForecastAccountCycle( qint64 v )
    {
      if (v < 1)
      {
        qDebug() << "setForecastAccountCycle: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

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

      if (!self()->isForecastAccountCycleImmutable())
        self()->mForecastAccountCycle = v;
    }

    /**
      Get Days of normal account cycle
    */
    static
    qint64 forecastAccountCycle()
    {
      return self()->mForecastAccountCycle;
    }

    /**
      Is Days of normal account cycle Immutable
    */
    static
    bool isForecastAccountCycleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "forecastAccountCycle" ) );
    }

    /**
      Set Number of historic cycles to use in forecast
    */
    static
    void setForecastCycles( qint64 v )
    {
      if (v < 1)
      {
        qDebug() << "setForecastCycles: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

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

      if (!self()->isForecastCyclesImmutable())
        self()->mForecastCycles = v;
    }

    /**
      Get Number of historic cycles to use in forecast
    */
    static
    qint64 forecastCycles()
    {
      return self()->mForecastCycles;
    }

    /**
      Is Number of historic cycles to use in forecast Immutable
    */
    static
    bool isForecastCyclesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "forecastCycles" ) );
    }

    /**
      Set Day of month to start forecast
    */
    static
    void setBeginForecastDay( qint64 v )
    {
      if (v < 0)
      {
        qDebug() << "setBeginForecastDay: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!self()->isBeginForecastDayImmutable())
        self()->mBeginForecastDay = v;
    }

    /**
      Get Day of month to start forecast
    */
    static
    qint64 beginForecastDay()
    {
      return self()->mBeginForecastDay;
    }

    /**
      Is Day of month to start forecast Immutable
    */
    static
    bool isBeginForecastDayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "beginForecastDay" ) );
    }

    /**
      Set Method to calculate history-based forecast
    */
    static
    void setHistoryMethod( int v )
    {
      if (!self()->isHistoryMethodImmutable())
        self()->mHistoryMethod = v;
    }

    /**
      Get Method to calculate history-based forecast
    */
    static
    int historyMethod()
    {
      return self()->mHistoryMethod;
    }

    /**
      Is Method to calculate history-based forecast Immutable
    */
    static
    bool isHistoryMethodImmutable()
    {
      return self()->isImmutable( QStringLiteral( "historyMethod" ) );
    }

    /**
      Set Skip opening date when fetching transactions
    */
    static
    void setSkipOpeningDate( bool v )
    {
      if (!self()->isSkipOpeningDateImmutable())
        self()->mSkipOpeningDate = v;
    }

    /**
      Get Skip opening date when fetching transactions
    */
    static
    bool skipOpeningDate()
    {
      return self()->mSkipOpeningDate;
    }

    /**
      Is Skip opening date when fetching transactions Immutable
    */
    static
    bool isSkipOpeningDateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "skipOpeningDate" ) );
    }

    /**
      Set Include future transaction when using Schedule Forecast
    */
    static
    void setIncludeFutureTransactions( bool v )
    {
      if (!self()->isIncludeFutureTransactionsImmutable())
        self()->mIncludeFutureTransactions = v;
    }

    /**
      Get Include future transaction when using Schedule Forecast
    */
    static
    bool includeFutureTransactions()
    {
      return self()->mIncludeFutureTransactions;
    }

    /**
      Is Include future transaction when using Schedule Forecast Immutable
    */
    static
    bool isIncludeFutureTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "includeFutureTransactions" ) );
    }

    /**
      Set Include scheduled transactions when using Schedule Forecast
    */
    static
    void setIncludeScheduledTransactions( bool v )
    {
      if (!self()->isIncludeScheduledTransactionsImmutable())
        self()->mIncludeScheduledTransactions = v;
    }

    /**
      Get Include scheduled transactions when using Schedule Forecast
    */
    static
    bool includeScheduledTransactions()
    {
      return self()->mIncludeScheduledTransactions;
    }

    /**
      Is Include scheduled transactions when using Schedule Forecast Immutable
    */
    static
    bool isIncludeScheduledTransactionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "includeScheduledTransactions" ) );
    }

  protected:
    KMyMoneySettings();
    friend class KMyMoneySettingsHelper;


    // General Options
    int mAutoFillTransaction;
    int mAutoFillDifference;
    bool mAutoFillUseMemos;
    bool mAutoIncCheckNumber;
    bool mAutoSaveFile;
    bool mAutoReconciliation;
    int mAutoBackupCopies;
    QString mBackupExtension;
    int mAutoSavePeriod;
    bool mAutoSaveOnClose;
    bool mCheckSchedule;
    int mCheckSchedulePreview;
    QString mExternalCalculator;
    QString mHolidayRegion;
    int mSchedulePreview;
    bool mFocusChangeIsEnter;
    bool mEnterMovesBetweenFields;
    bool mLedgerLens;
    bool mPriceHistoryUpdate;
    bool mTransactionForm;
    int mStartLastViewSelected;
    int mLastViewSelected;
    bool mWriteDataEncrypted;
    bool mEncryptRecover;
    QString mGpgRecipient;
    QStringList mGpgRecipientList;
    bool mExpertMode;
    bool mSyncLedgerInvestment;
    int mViewType;
    bool mFirstTimeRun;
    bool mStringMatchFromStart;
    QString mStdTransactionFormTabOrder;
    QString mStdTransactionRegisterTabOrder;

    // Homepage Options
    QString mItemList;
    double mZoomFactor;
    bool mRememberZoomFactor;
    bool mShowLimitInfo;
    bool mShowBalanceStatusOfOnlineAccounts;
    bool mShowCountOfUnmarkedTransactions;
    bool mShowCountOfClearedTransactions;
    bool mShowCountOfNotReconciledTransactions;
    bool mShowDateOfLastReconciliation;

    // Color Options
    bool mUseCustomColors;
    QColor mTransactionImportedColor;
    QColor mTransactionImportedText;
    QColor mTransactionMatchedColor;
    QColor mTransactionMatchedText;
    QColor mTransactionErroneousColor;
    QColor mMissingConversionRateColor;
    QColor mGroupMarkerColor;
    QColor mGroupMarkerText;
    QColor mFieldRequiredColor;

    // List Options
    bool mHideUnusedCategory;
    bool mShowAllAccounts;
    bool mShowCategoriesInAccountsView;
    bool mHideZeroBalanceEquities;
    bool mHideZeroBalanceAccounts;
    bool mHideZeroBalanceAccountsHome;
    bool mHideFinishedSchedules;
    bool mHideReconciledTransactions;
    bool mShowRegisterDetailed;
    bool mShowAllSplits;
    bool mShowPlannedScheduleDates;
    bool mShowGrid;
    bool mShowLedgerFilter;
    bool mShowFancyMarker;
    bool mShowFiscalMarker;
    int mShowReconciliationMarker;
    int mFiscalYearBegin;
    int mFiscalYearBeginDay;
    QDateTime mStartDate;
    QString mLogPath;
    bool mLogImportedStatements;
    bool mLogOfxTransactions;
    bool mUseSystemFont;
    QFont mListCellFont;
    QFont mListHeaderFont;
    QString mIconsTheme;
    QString mSortNormalView;
    QString mSortReconcileView;
    QString mSortSearchView;
    int mInitialDateFieldCursorPosition;
    int mDefaultReconciliationState;

    // Import options
    int mMatchInterval;
    bool mAskForPayeeCategory;

    // Internal Options
    QDateTime mLastUsedPostDate;

    // QIF Options
    QString mQifCash;
    QString mQifBank;
    QString mQifCreditCard;
    QString mQifAsset;
    QString mQifOpeningBalance;
    QString mQifInvoice;

    // Account View Settings
    bool mShowAccountsExpanded;

    // Chart Settings
    int mMaximumLegendItems;
    int mLineWidth;
    int mChartsPalette;
    QString mCssFileDefault;

    // Forecast Options
    int mForecastMethod;
    qint64 mForecastDays;
    qint64 mForecastAccountCycle;
    qint64 mForecastCycles;
    qint64 mBeginForecastDay;
    int mHistoryMethod;
    bool mSkipOpeningDate;
    bool mIncludeFutureTransactions;
    bool mIncludeScheduledTransactions;
    // Include custom additions
    #include "kmymoneysettings_addons.h"
};

#endif

