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

#include <kconfig_base_ee.hpp>

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

class DbAutotune : public KConfigBaseEE
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE("")
  public:

    DbAutotune( const QString & masterGroup, const QString & instanceIndex );
    ~DbAutotune() override;

    /**
      Set bypass
    */
    void setBypass( bool v )
    {
      if (v != mBypass && !isBypassImmutable()) {
        mBypass = v;
        Q_EMIT bypassChanged();
      }
    }

    Q_PROPERTY(bool bypass READ bypass WRITE setBypass NOTIFY bypassChanged)
    Q_PROPERTY(bool isBypassImmutable READ isBypassImmutable CONSTANT)
    Q_PROPERTY(bool defaultBypassValue READ defaultBypassValue CONSTANT)
    /**
      Get bypass
    */
    bool bypass() const
    {
      return mBypass;
    }

    /**
      Is bypass Immutable
    */
    bool isBypassImmutable() const
    {
      return isImmutable( QStringLiteral( "bypass" ) );
    }

    /**
      Get bypass default value
    */
    bool defaultBypassValue() const
    {
        return defaultBypassValue_helper();
    }

    /**
      Set inputGain
    */
    void setInputGain( double v )
    {
      if (v < -36)
      {
        qDebug() << "setInputGain: value " << v << " is less than the minimum value of -36";
        v = -36;
      }

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

      if (v != mInputGain && !isInputGainImmutable()) {
        mInputGain = v;
        Q_EMIT inputGainChanged();
      }
    }

    Q_PROPERTY(double inputGain READ inputGain WRITE setInputGain NOTIFY inputGainChanged)
    Q_PROPERTY(bool isInputGainImmutable READ isInputGainImmutable CONSTANT)
    Q_PROPERTY(double defaultInputGainValue READ defaultInputGainValue CONSTANT)
    /**
      Get inputGain
    */
    double inputGain() const
    {
      return mInputGain;
    }

    /**
      Is inputGain Immutable
    */
    bool isInputGainImmutable() const
    {
      return isImmutable( QStringLiteral( "inputGain" ) );
    }

    /**
      Get inputGain default value
    */
    double defaultInputGainValue() const
    {
        return defaultInputGainValue_helper();
    }

    /**
      Set outputGain
    */
    void setOutputGain( double v )
    {
      if (v < -36)
      {
        qDebug() << "setOutputGain: value " << v << " is less than the minimum value of -36";
        v = -36;
      }

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

      if (v != mOutputGain && !isOutputGainImmutable()) {
        mOutputGain = v;
        Q_EMIT outputGainChanged();
      }
    }

    Q_PROPERTY(double outputGain READ outputGain WRITE setOutputGain NOTIFY outputGainChanged)
    Q_PROPERTY(bool isOutputGainImmutable READ isOutputGainImmutable CONSTANT)
    Q_PROPERTY(double defaultOutputGainValue READ defaultOutputGainValue CONSTANT)
    /**
      Get outputGain
    */
    double outputGain() const
    {
      return mOutputGain;
    }

    /**
      Is outputGain Immutable
    */
    bool isOutputGainImmutable() const
    {
      return isImmutable( QStringLiteral( "outputGain" ) );
    }

    /**
      Get outputGain default value
    */
    double defaultOutputGainValue() const
    {
        return defaultOutputGainValue_helper();
    }

    /**
      Set modeLabels
    */
    void setModeLabels( const QStringList & v )
    {
      if (v != mModeLabels && !isModeLabelsImmutable()) {
        mModeLabels = v;
        Q_EMIT modeLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList modeLabels READ modeLabels WRITE setModeLabels NOTIFY modeLabelsChanged)
    Q_PROPERTY(bool isModeLabelsImmutable READ isModeLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultModeLabelsValue READ defaultModeLabelsValue CONSTANT)
    /**
      Get modeLabels
    */
    QStringList modeLabels() const
    {
      return mModeLabels;
    }

    /**
      Is modeLabels Immutable
    */
    bool isModeLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "modeLabels" ) );
    }

    /**
      Get modeLabels default value
    */
    QStringList defaultModeLabelsValue() const
    {
        return defaultModeLabelsValue_helper();
    }

    /**
      Set Mode
    */
    void setMode( int v )
    {
      if (v != mMode && !isModeImmutable()) {
        mMode = v;
        Q_EMIT modeChanged();
      }
    }

    Q_PROPERTY(int mode READ mode WRITE setMode NOTIFY modeChanged)
    Q_PROPERTY(bool isModeImmutable READ isModeImmutable CONSTANT)
    Q_PROPERTY(int defaultModeValue READ defaultModeValue CONSTANT)
    /**
      Get Mode
    */
    int mode() const
    {
      return mMode;
    }

    /**
      Is Mode Immutable
    */
    bool isModeImmutable() const
    {
      return isImmutable( QStringLiteral( "mode" ) );
    }

    /**
      Get Mode default value
    */
    int defaultModeValue() const
    {
        return defaultModeValue_helper();
    }

    /**
      Set Filter Channel
    */
    void setChannelFilter( int v )
    {
      if (v < 0)
      {
        qDebug() << "setChannelFilter: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (v != mChannelFilter && !isChannelFilterImmutable()) {
        mChannelFilter = v;
        Q_EMIT channelFilterChanged();
      }
    }

    Q_PROPERTY(int channelFilter READ channelFilter WRITE setChannelFilter NOTIFY channelFilterChanged)
    Q_PROPERTY(bool isChannelFilterImmutable READ isChannelFilterImmutable CONSTANT)
    Q_PROPERTY(int defaultChannelFilterValue READ defaultChannelFilterValue CONSTANT)
    /**
      Get Filter Channel
    */
    int channelFilter() const
    {
      return mChannelFilter;
    }

    /**
      Is Filter Channel Immutable
    */
    bool isChannelFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "channelFilter" ) );
    }

    /**
      Get Filter Channel default value
    */
    int defaultChannelFilterValue() const
    {
        return defaultChannelFilterValue_helper();
    }

    /**
      Set Tuning frequency
    */
    void setTuning( double v )
    {
      if (v < 400.0)
      {
        qDebug() << "setTuning: value " << v << " is less than the minimum value of 400.0";
        v = 400.0;
      }

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

      if (v != mTuning && !isTuningImmutable()) {
        mTuning = v;
        Q_EMIT tuningChanged();
      }
    }

    Q_PROPERTY(double tuning READ tuning WRITE setTuning NOTIFY tuningChanged)
    Q_PROPERTY(bool isTuningImmutable READ isTuningImmutable CONSTANT)
    Q_PROPERTY(double defaultTuningValue READ defaultTuningValue CONSTANT)
    /**
      Get Tuning frequency
    */
    double tuning() const
    {
      return mTuning;
    }

    /**
      Is Tuning frequency Immutable
    */
    bool isTuningImmutable() const
    {
      return isImmutable( QStringLiteral( "tuning" ) );
    }

    /**
      Get Tuning frequency default value
    */
    double defaultTuningValue() const
    {
        return defaultTuningValue_helper();
    }

    /**
      Set Bias
    */
    void setBias( double v )
    {
      if (v < 0.0)
      {
        qDebug() << "setBias: value " << v << " is less than the minimum value of 0.0";
        v = 0.0;
      }

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

      if (v != mBias && !isBiasImmutable()) {
        mBias = v;
        Q_EMIT biasChanged();
      }
    }

    Q_PROPERTY(double bias READ bias WRITE setBias NOTIFY biasChanged)
    Q_PROPERTY(bool isBiasImmutable READ isBiasImmutable CONSTANT)
    Q_PROPERTY(double defaultBiasValue READ defaultBiasValue CONSTANT)
    /**
      Get Bias
    */
    double bias() const
    {
      return mBias;
    }

    /**
      Is Bias Immutable
    */
    bool isBiasImmutable() const
    {
      return isImmutable( QStringLiteral( "bias" ) );
    }

    /**
      Get Bias default value
    */
    double defaultBiasValue() const
    {
        return defaultBiasValue_helper();
    }

    /**
      Set Filter
    */
    void setFilter( double v )
    {
      if (v < 0.02)
      {
        qDebug() << "setFilter: value " << v << " is less than the minimum value of 0.02";
        v = 0.02;
      }

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

      if (v != mFilter && !isFilterImmutable()) {
        mFilter = v;
        Q_EMIT filterChanged();
      }
    }

    Q_PROPERTY(double filter READ filter WRITE setFilter NOTIFY filterChanged)
    Q_PROPERTY(bool isFilterImmutable READ isFilterImmutable CONSTANT)
    Q_PROPERTY(double defaultFilterValue READ defaultFilterValue CONSTANT)
    /**
      Get Filter
    */
    double filter() const
    {
      return mFilter;
    }

    /**
      Is Filter Immutable
    */
    bool isFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "filter" ) );
    }

    /**
      Get Filter default value
    */
    double defaultFilterValue() const
    {
        return defaultFilterValue_helper();
    }

    /**
      Set Correction
    */
    void setCorrection( double v )
    {
      if (v < 0.0)
      {
        qDebug() << "setCorrection: value " << v << " is less than the minimum value of 0.0";
        v = 0.0;
      }

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

      if (v != mCorrection && !isCorrectionImmutable()) {
        mCorrection = v;
        Q_EMIT correctionChanged();
      }
    }

    Q_PROPERTY(double correction READ correction WRITE setCorrection NOTIFY correctionChanged)
    Q_PROPERTY(bool isCorrectionImmutable READ isCorrectionImmutable CONSTANT)
    Q_PROPERTY(double defaultCorrectionValue READ defaultCorrectionValue CONSTANT)
    /**
      Get Correction
    */
    double correction() const
    {
      return mCorrection;
    }

    /**
      Is Correction Immutable
    */
    bool isCorrectionImmutable() const
    {
      return isImmutable( QStringLiteral( "correction" ) );
    }

    /**
      Get Correction default value
    */
    double defaultCorrectionValue() const
    {
        return defaultCorrectionValue_helper();
    }

    /**
      Set Offset
    */
    void setOffset( double v )
    {
      if (v < -2.0)
      {
        qDebug() << "setOffset: value " << v << " is less than the minimum value of -2.0";
        v = -2.0;
      }

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

      if (v != mOffset && !isOffsetImmutable()) {
        mOffset = v;
        Q_EMIT offsetChanged();
      }
    }

    Q_PROPERTY(double offset READ offset WRITE setOffset NOTIFY offsetChanged)
    Q_PROPERTY(bool isOffsetImmutable READ isOffsetImmutable CONSTANT)
    Q_PROPERTY(double defaultOffsetValue READ defaultOffsetValue CONSTANT)
    /**
      Get Offset
    */
    double offset() const
    {
      return mOffset;
    }

    /**
      Is Offset Immutable
    */
    bool isOffsetImmutable() const
    {
      return isImmutable( QStringLiteral( "offset" ) );
    }

    /**
      Get Offset default value
    */
    double defaultOffsetValue() const
    {
        return defaultOffsetValue_helper();
    }

    /**
      Set Bend Range
    */
    void setBendRange( double v )
    {
      if (v < 0.0)
      {
        qDebug() << "setBendRange: value " << v << " is less than the minimum value of 0.0";
        v = 0.0;
      }

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

      if (v != mBendRange && !isBendRangeImmutable()) {
        mBendRange = v;
        Q_EMIT bendRangeChanged();
      }
    }

    Q_PROPERTY(double bendRange READ bendRange WRITE setBendRange NOTIFY bendRangeChanged)
    Q_PROPERTY(bool isBendRangeImmutable READ isBendRangeImmutable CONSTANT)
    Q_PROPERTY(double defaultBendRangeValue READ defaultBendRangeValue CONSTANT)
    /**
      Get Bend Range
    */
    double bendRange() const
    {
      return mBendRange;
    }

    /**
      Is Bend Range Immutable
    */
    bool isBendRangeImmutable() const
    {
      return isImmutable( QStringLiteral( "bendRange" ) );
    }

    /**
      Get Bend Range default value
    */
    double defaultBendRangeValue() const
    {
        return defaultBendRangeValue_helper();
    }

    /**
      Set Fast Correction
    */
    void setFastMode( bool v )
    {
      if (v != mFastMode && !isFastModeImmutable()) {
        mFastMode = v;
        Q_EMIT fastModeChanged();
      }
    }

    Q_PROPERTY(bool fastMode READ fastMode WRITE setFastMode NOTIFY fastModeChanged)
    Q_PROPERTY(bool isFastModeImmutable READ isFastModeImmutable CONSTANT)
    Q_PROPERTY(bool defaultFastModeValue READ defaultFastModeValue CONSTANT)
    /**
      Get Fast Correction
    */
    bool fastMode() const
    {
      return mFastMode;
    }

    /**
      Is Fast Correction Immutable
    */
    bool isFastModeImmutable() const
    {
      return isImmutable( QStringLiteral( "fastMode" ) );
    }

    /**
      Get Fast Correction default value
    */
    bool defaultFastModeValue() const
    {
        return defaultFastModeValue_helper();
    }

    /**
      Set noteC
    */
    void setNoteC( bool v )
    {
      if (v != mNoteC && !isNoteCImmutable()) {
        mNoteC = v;
        Q_EMIT noteCChanged();
      }
    }

    Q_PROPERTY(bool noteC READ noteC WRITE setNoteC NOTIFY noteCChanged)
    Q_PROPERTY(bool isNoteCImmutable READ isNoteCImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteCValue READ defaultNoteCValue CONSTANT)
    /**
      Get noteC
    */
    bool noteC() const
    {
      return mNoteC;
    }

    /**
      Is noteC Immutable
    */
    bool isNoteCImmutable() const
    {
      return isImmutable( QStringLiteral( "noteC" ) );
    }

    /**
      Get noteC default value
    */
    bool defaultNoteCValue() const
    {
        return defaultNoteCValue_helper();
    }

    /**
      Set noteCSharp
    */
    void setNoteCSharp( bool v )
    {
      if (v != mNoteCSharp && !isNoteCSharpImmutable()) {
        mNoteCSharp = v;
        Q_EMIT noteCSharpChanged();
      }
    }

    Q_PROPERTY(bool noteCSharp READ noteCSharp WRITE setNoteCSharp NOTIFY noteCSharpChanged)
    Q_PROPERTY(bool isNoteCSharpImmutable READ isNoteCSharpImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteCSharpValue READ defaultNoteCSharpValue CONSTANT)
    /**
      Get noteCSharp
    */
    bool noteCSharp() const
    {
      return mNoteCSharp;
    }

    /**
      Is noteCSharp Immutable
    */
    bool isNoteCSharpImmutable() const
    {
      return isImmutable( QStringLiteral( "noteCSharp" ) );
    }

    /**
      Get noteCSharp default value
    */
    bool defaultNoteCSharpValue() const
    {
        return defaultNoteCSharpValue_helper();
    }

    /**
      Set noteD
    */
    void setNoteD( bool v )
    {
      if (v != mNoteD && !isNoteDImmutable()) {
        mNoteD = v;
        Q_EMIT noteDChanged();
      }
    }

    Q_PROPERTY(bool noteD READ noteD WRITE setNoteD NOTIFY noteDChanged)
    Q_PROPERTY(bool isNoteDImmutable READ isNoteDImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteDValue READ defaultNoteDValue CONSTANT)
    /**
      Get noteD
    */
    bool noteD() const
    {
      return mNoteD;
    }

    /**
      Is noteD Immutable
    */
    bool isNoteDImmutable() const
    {
      return isImmutable( QStringLiteral( "noteD" ) );
    }

    /**
      Get noteD default value
    */
    bool defaultNoteDValue() const
    {
        return defaultNoteDValue_helper();
    }

    /**
      Set noteDSharp
    */
    void setNoteDSharp( bool v )
    {
      if (v != mNoteDSharp && !isNoteDSharpImmutable()) {
        mNoteDSharp = v;
        Q_EMIT noteDSharpChanged();
      }
    }

    Q_PROPERTY(bool noteDSharp READ noteDSharp WRITE setNoteDSharp NOTIFY noteDSharpChanged)
    Q_PROPERTY(bool isNoteDSharpImmutable READ isNoteDSharpImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteDSharpValue READ defaultNoteDSharpValue CONSTANT)
    /**
      Get noteDSharp
    */
    bool noteDSharp() const
    {
      return mNoteDSharp;
    }

    /**
      Is noteDSharp Immutable
    */
    bool isNoteDSharpImmutable() const
    {
      return isImmutable( QStringLiteral( "noteDSharp" ) );
    }

    /**
      Get noteDSharp default value
    */
    bool defaultNoteDSharpValue() const
    {
        return defaultNoteDSharpValue_helper();
    }

    /**
      Set noteE
    */
    void setNoteE( bool v )
    {
      if (v != mNoteE && !isNoteEImmutable()) {
        mNoteE = v;
        Q_EMIT noteEChanged();
      }
    }

    Q_PROPERTY(bool noteE READ noteE WRITE setNoteE NOTIFY noteEChanged)
    Q_PROPERTY(bool isNoteEImmutable READ isNoteEImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteEValue READ defaultNoteEValue CONSTANT)
    /**
      Get noteE
    */
    bool noteE() const
    {
      return mNoteE;
    }

    /**
      Is noteE Immutable
    */
    bool isNoteEImmutable() const
    {
      return isImmutable( QStringLiteral( "noteE" ) );
    }

    /**
      Get noteE default value
    */
    bool defaultNoteEValue() const
    {
        return defaultNoteEValue_helper();
    }

    /**
      Set noteF
    */
    void setNoteF( bool v )
    {
      if (v != mNoteF && !isNoteFImmutable()) {
        mNoteF = v;
        Q_EMIT noteFChanged();
      }
    }

    Q_PROPERTY(bool noteF READ noteF WRITE setNoteF NOTIFY noteFChanged)
    Q_PROPERTY(bool isNoteFImmutable READ isNoteFImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteFValue READ defaultNoteFValue CONSTANT)
    /**
      Get noteF
    */
    bool noteF() const
    {
      return mNoteF;
    }

    /**
      Is noteF Immutable
    */
    bool isNoteFImmutable() const
    {
      return isImmutable( QStringLiteral( "noteF" ) );
    }

    /**
      Get noteF default value
    */
    bool defaultNoteFValue() const
    {
        return defaultNoteFValue_helper();
    }

    /**
      Set noteFSharp
    */
    void setNoteFSharp( bool v )
    {
      if (v != mNoteFSharp && !isNoteFSharpImmutable()) {
        mNoteFSharp = v;
        Q_EMIT noteFSharpChanged();
      }
    }

    Q_PROPERTY(bool noteFSharp READ noteFSharp WRITE setNoteFSharp NOTIFY noteFSharpChanged)
    Q_PROPERTY(bool isNoteFSharpImmutable READ isNoteFSharpImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteFSharpValue READ defaultNoteFSharpValue CONSTANT)
    /**
      Get noteFSharp
    */
    bool noteFSharp() const
    {
      return mNoteFSharp;
    }

    /**
      Is noteFSharp Immutable
    */
    bool isNoteFSharpImmutable() const
    {
      return isImmutable( QStringLiteral( "noteFSharp" ) );
    }

    /**
      Get noteFSharp default value
    */
    bool defaultNoteFSharpValue() const
    {
        return defaultNoteFSharpValue_helper();
    }

    /**
      Set noteG
    */
    void setNoteG( bool v )
    {
      if (v != mNoteG && !isNoteGImmutable()) {
        mNoteG = v;
        Q_EMIT noteGChanged();
      }
    }

    Q_PROPERTY(bool noteG READ noteG WRITE setNoteG NOTIFY noteGChanged)
    Q_PROPERTY(bool isNoteGImmutable READ isNoteGImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteGValue READ defaultNoteGValue CONSTANT)
    /**
      Get noteG
    */
    bool noteG() const
    {
      return mNoteG;
    }

    /**
      Is noteG Immutable
    */
    bool isNoteGImmutable() const
    {
      return isImmutable( QStringLiteral( "noteG" ) );
    }

    /**
      Get noteG default value
    */
    bool defaultNoteGValue() const
    {
        return defaultNoteGValue_helper();
    }

    /**
      Set noteGSharp
    */
    void setNoteGSharp( bool v )
    {
      if (v != mNoteGSharp && !isNoteGSharpImmutable()) {
        mNoteGSharp = v;
        Q_EMIT noteGSharpChanged();
      }
    }

    Q_PROPERTY(bool noteGSharp READ noteGSharp WRITE setNoteGSharp NOTIFY noteGSharpChanged)
    Q_PROPERTY(bool isNoteGSharpImmutable READ isNoteGSharpImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteGSharpValue READ defaultNoteGSharpValue CONSTANT)
    /**
      Get noteGSharp
    */
    bool noteGSharp() const
    {
      return mNoteGSharp;
    }

    /**
      Is noteGSharp Immutable
    */
    bool isNoteGSharpImmutable() const
    {
      return isImmutable( QStringLiteral( "noteGSharp" ) );
    }

    /**
      Get noteGSharp default value
    */
    bool defaultNoteGSharpValue() const
    {
        return defaultNoteGSharpValue_helper();
    }

    /**
      Set noteA
    */
    void setNoteA( bool v )
    {
      if (v != mNoteA && !isNoteAImmutable()) {
        mNoteA = v;
        Q_EMIT noteAChanged();
      }
    }

    Q_PROPERTY(bool noteA READ noteA WRITE setNoteA NOTIFY noteAChanged)
    Q_PROPERTY(bool isNoteAImmutable READ isNoteAImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteAValue READ defaultNoteAValue CONSTANT)
    /**
      Get noteA
    */
    bool noteA() const
    {
      return mNoteA;
    }

    /**
      Is noteA Immutable
    */
    bool isNoteAImmutable() const
    {
      return isImmutable( QStringLiteral( "noteA" ) );
    }

    /**
      Get noteA default value
    */
    bool defaultNoteAValue() const
    {
        return defaultNoteAValue_helper();
    }

    /**
      Set noteASharp
    */
    void setNoteASharp( bool v )
    {
      if (v != mNoteASharp && !isNoteASharpImmutable()) {
        mNoteASharp = v;
        Q_EMIT noteASharpChanged();
      }
    }

    Q_PROPERTY(bool noteASharp READ noteASharp WRITE setNoteASharp NOTIFY noteASharpChanged)
    Q_PROPERTY(bool isNoteASharpImmutable READ isNoteASharpImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteASharpValue READ defaultNoteASharpValue CONSTANT)
    /**
      Get noteASharp
    */
    bool noteASharp() const
    {
      return mNoteASharp;
    }

    /**
      Is noteASharp Immutable
    */
    bool isNoteASharpImmutable() const
    {
      return isImmutable( QStringLiteral( "noteASharp" ) );
    }

    /**
      Get noteASharp default value
    */
    bool defaultNoteASharpValue() const
    {
        return defaultNoteASharpValue_helper();
    }

    /**
      Set noteB
    */
    void setNoteB( bool v )
    {
      if (v != mNoteB && !isNoteBImmutable()) {
        mNoteB = v;
        Q_EMIT noteBChanged();
      }
    }

    Q_PROPERTY(bool noteB READ noteB WRITE setNoteB NOTIFY noteBChanged)
    Q_PROPERTY(bool isNoteBImmutable READ isNoteBImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteBValue READ defaultNoteBValue CONSTANT)
    /**
      Get noteB
    */
    bool noteB() const
    {
      return mNoteB;
    }

    /**
      Is noteB Immutable
    */
    bool isNoteBImmutable() const
    {
      return isImmutable( QStringLiteral( "noteB" ) );
    }

    /**
      Get noteB default value
    */
    bool defaultNoteBValue() const
    {
        return defaultNoteBValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalModeLabelsChanged = 4,
      signalModeChanged = 5,
      signalChannelFilterChanged = 6,
      signalTuningChanged = 7,
      signalBiasChanged = 8,
      signalFilterChanged = 9,
      signalCorrectionChanged = 10,
      signalOffsetChanged = 11,
      signalBendRangeChanged = 12,
      signalFastModeChanged = 13,
      signalNoteCChanged = 14,
      signalNoteCSharpChanged = 15,
      signalNoteDChanged = 16,
      signalNoteDSharpChanged = 17,
      signalNoteEChanged = 18,
      signalNoteFChanged = 19,
      signalNoteFSharpChanged = 20,
      signalNoteGChanged = 21,
      signalNoteGSharpChanged = 22,
      signalNoteAChanged = 23,
      signalNoteASharpChanged = 24,
      signalNoteBChanged = 25
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void modeLabelsChanged();

    void modeChanged();

    void channelFilterChanged();

    void tuningChanged();

    void biasChanged();

    void filterChanged();

    void correctionChanged();

    void offsetChanged();

    void bendRangeChanged();

    void fastModeChanged();

    void noteCChanged();

    void noteCSharpChanged();

    void noteDChanged();

    void noteDSharpChanged();

    void noteEChanged();

    void noteFChanged();

    void noteFSharpChanged();

    void noteGChanged();

    void noteGSharpChanged();

    void noteAChanged();

    void noteASharpChanged();

    void noteBChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // Autotune#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    QStringList mModeLabels;
    QStringList defaultModeLabelsValue_helper() const;
    int mMode;
    int defaultModeValue_helper() const;
    int mChannelFilter;
    int defaultChannelFilterValue_helper() const;
    double mTuning;
    double defaultTuningValue_helper() const;
    double mBias;
    double defaultBiasValue_helper() const;
    double mFilter;
    double defaultFilterValue_helper() const;
    double mCorrection;
    double defaultCorrectionValue_helper() const;
    double mOffset;
    double defaultOffsetValue_helper() const;
    double mBendRange;
    double defaultBendRangeValue_helper() const;
    bool mFastMode;
    bool defaultFastModeValue_helper() const;
    bool mNoteC;
    bool defaultNoteCValue_helper() const;
    bool mNoteCSharp;
    bool defaultNoteCSharpValue_helper() const;
    bool mNoteD;
    bool defaultNoteDValue_helper() const;
    bool mNoteDSharp;
    bool defaultNoteDSharpValue_helper() const;
    bool mNoteE;
    bool defaultNoteEValue_helper() const;
    bool mNoteF;
    bool defaultNoteFValue_helper() const;
    bool mNoteFSharp;
    bool defaultNoteFSharpValue_helper() const;
    bool mNoteG;
    bool defaultNoteGValue_helper() const;
    bool mNoteGSharp;
    bool defaultNoteGSharpValue_helper() const;
    bool mNoteA;
    bool defaultNoteAValue_helper() const;
    bool mNoteASharp;
    bool defaultNoteASharpValue_helper() const;
    bool mNoteB;
    bool defaultNoteBValue_helper() const;
};

#endif

