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

#include "kconfig_base_ee.hpp"

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

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

    DbDeesser( const QString & masterGroup, const QString & instanceIndex );
    ~DbDeesser() 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 detectionLabels
    */
    void setDetectionLabels( const QStringList & v )
    {
      if (v != mDetectionLabels && !isDetectionLabelsImmutable()) {
        mDetectionLabels = v;
        Q_EMIT detectionLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList detectionLabels READ detectionLabels WRITE setDetectionLabels NOTIFY detectionLabelsChanged)
    Q_PROPERTY(bool isDetectionLabelsImmutable READ isDetectionLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultDetectionLabelsValue READ defaultDetectionLabelsValue CONSTANT)
    /**
      Get detectionLabels
    */
    QStringList detectionLabels() const
    {
      return mDetectionLabels;
    }

    /**
      Is detectionLabels Immutable
    */
    bool isDetectionLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "detectionLabels" ) );
    }

    /**
      Get detectionLabels default value
    */
    QStringList defaultDetectionLabelsValue() const
    {
        return defaultDetectionLabelsValue_helper();
    }

    /**
      Set detection
    */
    void setDetection( int v )
    {
      if (v != mDetection && !isDetectionImmutable()) {
        mDetection = v;
        Q_EMIT detectionChanged();
      }
    }

    Q_PROPERTY(int detection READ detection WRITE setDetection NOTIFY detectionChanged)
    Q_PROPERTY(bool isDetectionImmutable READ isDetectionImmutable CONSTANT)
    Q_PROPERTY(int defaultDetectionValue READ defaultDetectionValue CONSTANT)
    /**
      Get detection
    */
    int detection() const
    {
      return mDetection;
    }

    /**
      Is detection Immutable
    */
    bool isDetectionImmutable() const
    {
      return isImmutable( QStringLiteral( "detection" ) );
    }

    /**
      Get detection default value
    */
    int defaultDetectionValue() const
    {
        return defaultDetectionValue_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 threshold
    */
    void setThreshold( double v )
    {
      if (v < -60)
      {
        qDebug() << "setThreshold: value " << v << " is less than the minimum value of -60";
        v = -60;
      }

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

      if (v != mThreshold && !isThresholdImmutable()) {
        mThreshold = v;
        Q_EMIT thresholdChanged();
      }
    }

    Q_PROPERTY(double threshold READ threshold WRITE setThreshold NOTIFY thresholdChanged)
    Q_PROPERTY(bool isThresholdImmutable READ isThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultThresholdValue READ defaultThresholdValue CONSTANT)
    /**
      Get threshold
    */
    double threshold() const
    {
      return mThreshold;
    }

    /**
      Is threshold Immutable
    */
    bool isThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "threshold" ) );
    }

    /**
      Get threshold default value
    */
    double defaultThresholdValue() const
    {
        return defaultThresholdValue_helper();
    }

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

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

      if (v != mRatio && !isRatioImmutable()) {
        mRatio = v;
        Q_EMIT ratioChanged();
      }
    }

    Q_PROPERTY(double ratio READ ratio WRITE setRatio NOTIFY ratioChanged)
    Q_PROPERTY(bool isRatioImmutable READ isRatioImmutable CONSTANT)
    Q_PROPERTY(double defaultRatioValue READ defaultRatioValue CONSTANT)
    /**
      Get ratio
    */
    double ratio() const
    {
      return mRatio;
    }

    /**
      Is ratio Immutable
    */
    bool isRatioImmutable() const
    {
      return isImmutable( QStringLiteral( "ratio" ) );
    }

    /**
      Get ratio default value
    */
    double defaultRatioValue() const
    {
        return defaultRatioValue_helper();
    }

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

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

      if (v != mLaxity && !isLaxityImmutable()) {
        mLaxity = v;
        Q_EMIT laxityChanged();
      }
    }

    Q_PROPERTY(int laxity READ laxity WRITE setLaxity NOTIFY laxityChanged)
    Q_PROPERTY(bool isLaxityImmutable READ isLaxityImmutable CONSTANT)
    Q_PROPERTY(int defaultLaxityValue READ defaultLaxityValue CONSTANT)
    /**
      Get laxity
    */
    int laxity() const
    {
      return mLaxity;
    }

    /**
      Is laxity Immutable
    */
    bool isLaxityImmutable() const
    {
      return isImmutable( QStringLiteral( "laxity" ) );
    }

    /**
      Get laxity default value
    */
    int defaultLaxityValue() const
    {
        return defaultLaxityValue_helper();
    }

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

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

      if (v != mMakeup && !isMakeupImmutable()) {
        mMakeup = v;
        Q_EMIT makeupChanged();
      }
    }

    Q_PROPERTY(double makeup READ makeup WRITE setMakeup NOTIFY makeupChanged)
    Q_PROPERTY(bool isMakeupImmutable READ isMakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultMakeupValue READ defaultMakeupValue CONSTANT)
    /**
      Get makeup
    */
    double makeup() const
    {
      return mMakeup;
    }

    /**
      Is makeup Immutable
    */
    bool isMakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "makeup" ) );
    }

    /**
      Get makeup default value
    */
    double defaultMakeupValue() const
    {
        return defaultMakeupValue_helper();
    }

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

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

      if (v != mF1Freq && !isF1FreqImmutable()) {
        mF1Freq = v;
        Q_EMIT f1FreqChanged();
      }
    }

    Q_PROPERTY(double f1Freq READ f1Freq WRITE setF1Freq NOTIFY f1FreqChanged)
    Q_PROPERTY(bool isF1FreqImmutable READ isF1FreqImmutable CONSTANT)
    Q_PROPERTY(double defaultF1FreqValue READ defaultF1FreqValue CONSTANT)
    /**
      Get f1Freq
    */
    double f1Freq() const
    {
      return mF1Freq;
    }

    /**
      Is f1Freq Immutable
    */
    bool isF1FreqImmutable() const
    {
      return isImmutable( QStringLiteral( "f1Freq" ) );
    }

    /**
      Get f1Freq default value
    */
    double defaultF1FreqValue() const
    {
        return defaultF1FreqValue_helper();
    }

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

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

      if (v != mF2Freq && !isF2FreqImmutable()) {
        mF2Freq = v;
        Q_EMIT f2FreqChanged();
      }
    }

    Q_PROPERTY(double f2Freq READ f2Freq WRITE setF2Freq NOTIFY f2FreqChanged)
    Q_PROPERTY(bool isF2FreqImmutable READ isF2FreqImmutable CONSTANT)
    Q_PROPERTY(double defaultF2FreqValue READ defaultF2FreqValue CONSTANT)
    /**
      Get f2Freq
    */
    double f2Freq() const
    {
      return mF2Freq;
    }

    /**
      Is f2Freq Immutable
    */
    bool isF2FreqImmutable() const
    {
      return isImmutable( QStringLiteral( "f2Freq" ) );
    }

    /**
      Get f2Freq default value
    */
    double defaultF2FreqValue() const
    {
        return defaultF2FreqValue_helper();
    }

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

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

      if (v != mF1Level && !isF1LevelImmutable()) {
        mF1Level = v;
        Q_EMIT f1LevelChanged();
      }
    }

    Q_PROPERTY(double f1Level READ f1Level WRITE setF1Level NOTIFY f1LevelChanged)
    Q_PROPERTY(bool isF1LevelImmutable READ isF1LevelImmutable CONSTANT)
    Q_PROPERTY(double defaultF1LevelValue READ defaultF1LevelValue CONSTANT)
    /**
      Get f1Level
    */
    double f1Level() const
    {
      return mF1Level;
    }

    /**
      Is f1Level Immutable
    */
    bool isF1LevelImmutable() const
    {
      return isImmutable( QStringLiteral( "f1Level" ) );
    }

    /**
      Get f1Level default value
    */
    double defaultF1LevelValue() const
    {
        return defaultF1LevelValue_helper();
    }

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

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

      if (v != mF2Level && !isF2LevelImmutable()) {
        mF2Level = v;
        Q_EMIT f2LevelChanged();
      }
    }

    Q_PROPERTY(double f2Level READ f2Level WRITE setF2Level NOTIFY f2LevelChanged)
    Q_PROPERTY(bool isF2LevelImmutable READ isF2LevelImmutable CONSTANT)
    Q_PROPERTY(double defaultF2LevelValue READ defaultF2LevelValue CONSTANT)
    /**
      Get f2Level
    */
    double f2Level() const
    {
      return mF2Level;
    }

    /**
      Is f2Level Immutable
    */
    bool isF2LevelImmutable() const
    {
      return isImmutable( QStringLiteral( "f2Level" ) );
    }

    /**
      Get f2Level default value
    */
    double defaultF2LevelValue() const
    {
        return defaultF2LevelValue_helper();
    }

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

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

      if (v != mF2Q && !isF2QImmutable()) {
        mF2Q = v;
        Q_EMIT f2QChanged();
      }
    }

    Q_PROPERTY(double f2Q READ f2Q WRITE setF2Q NOTIFY f2QChanged)
    Q_PROPERTY(bool isF2QImmutable READ isF2QImmutable CONSTANT)
    Q_PROPERTY(double defaultF2QValue READ defaultF2QValue CONSTANT)
    /**
      Get f2Q
    */
    double f2Q() const
    {
      return mF2Q;
    }

    /**
      Is f2Q Immutable
    */
    bool isF2QImmutable() const
    {
      return isImmutable( QStringLiteral( "f2Q" ) );
    }

    /**
      Get f2Q default value
    */
    double defaultF2QValue() const
    {
        return defaultF2QValue_helper();
    }

    /**
      Set scListen
    */
    void setScListen( bool v )
    {
      if (v != mScListen && !isScListenImmutable()) {
        mScListen = v;
        Q_EMIT scListenChanged();
      }
    }

    Q_PROPERTY(bool scListen READ scListen WRITE setScListen NOTIFY scListenChanged)
    Q_PROPERTY(bool isScListenImmutable READ isScListenImmutable CONSTANT)
    Q_PROPERTY(bool defaultScListenValue READ defaultScListenValue CONSTANT)
    /**
      Get scListen
    */
    bool scListen() const
    {
      return mScListen;
    }

    /**
      Is scListen Immutable
    */
    bool isScListenImmutable() const
    {
      return isImmutable( QStringLiteral( "scListen" ) );
    }

    /**
      Get scListen default value
    */
    bool defaultScListenValue() const
    {
        return defaultScListenValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalDetectionLabelsChanged = 4,
      signalDetectionChanged = 5,
      signalModeLabelsChanged = 6,
      signalModeChanged = 7,
      signalThresholdChanged = 8,
      signalRatioChanged = 9,
      signalLaxityChanged = 10,
      signalMakeupChanged = 11,
      signalF1FreqChanged = 12,
      signalF2FreqChanged = 13,
      signalF1LevelChanged = 14,
      signalF2LevelChanged = 15,
      signalF2QChanged = 16,
      signalScListenChanged = 17
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void detectionLabelsChanged();

    void detectionChanged();

    void modeLabelsChanged();

    void modeChanged();

    void thresholdChanged();

    void ratioChanged();

    void laxityChanged();

    void makeupChanged();

    void f1FreqChanged();

    void f2FreqChanged();

    void f1LevelChanged();

    void f2LevelChanged();

    void f2QChanged();

    void scListenChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // Deesser#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    QStringList mDetectionLabels;
    QStringList defaultDetectionLabelsValue_helper() const;
    int mDetection;
    int defaultDetectionValue_helper() const;
    QStringList mModeLabels;
    QStringList defaultModeLabelsValue_helper() const;
    int mMode;
    int defaultModeValue_helper() const;
    double mThreshold;
    double defaultThresholdValue_helper() const;
    double mRatio;
    double defaultRatioValue_helper() const;
    int mLaxity;
    int defaultLaxityValue_helper() const;
    double mMakeup;
    double defaultMakeupValue_helper() const;
    double mF1Freq;
    double defaultF1FreqValue_helper() const;
    double mF2Freq;
    double defaultF2FreqValue_helper() const;
    double mF1Level;
    double defaultF1LevelValue_helper() const;
    double mF2Level;
    double defaultF2LevelValue_helper() const;
    double mF2Q;
    double defaultF2QValue_helper() const;
    bool mScListen;
    bool defaultScListenValue_helper() const;
};

#endif

