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

#include "kconfig_base_ee.hpp"

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

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

    DbDelay( const QString & masterGroup, const QString & instanceIndex );
    ~DbDelay() 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 dryL
    */
    void setDryL( double v )
    {
      if (v < -80.01)
      {
        qDebug() << "setDryL: value " << v << " is less than the minimum value of -80.01";
        v = -80.01;
      }

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

      if (v != mDryL && !isDryLImmutable()) {
        mDryL = v;
        Q_EMIT dryLChanged();
      }
    }

    Q_PROPERTY(double dryL READ dryL WRITE setDryL NOTIFY dryLChanged)
    Q_PROPERTY(bool isDryLImmutable READ isDryLImmutable CONSTANT)
    Q_PROPERTY(double defaultDryLValue READ defaultDryLValue CONSTANT)
    /**
      Get dryL
    */
    double dryL() const
    {
      return mDryL;
    }

    /**
      Is dryL Immutable
    */
    bool isDryLImmutable() const
    {
      return isImmutable( QStringLiteral( "dryL" ) );
    }

    /**
      Get dryL default value
    */
    double defaultDryLValue() const
    {
        return defaultDryLValue_helper();
    }

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

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

      if (v != mDryR && !isDryRImmutable()) {
        mDryR = v;
        Q_EMIT dryRChanged();
      }
    }

    Q_PROPERTY(double dryR READ dryR WRITE setDryR NOTIFY dryRChanged)
    Q_PROPERTY(bool isDryRImmutable READ isDryRImmutable CONSTANT)
    Q_PROPERTY(double defaultDryRValue READ defaultDryRValue CONSTANT)
    /**
      Get dryR
    */
    double dryR() const
    {
      return mDryR;
    }

    /**
      Is dryR Immutable
    */
    bool isDryRImmutable() const
    {
      return isImmutable( QStringLiteral( "dryR" ) );
    }

    /**
      Get dryR default value
    */
    double defaultDryRValue() const
    {
        return defaultDryRValue_helper();
    }

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

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

      if (v != mWetL && !isWetLImmutable()) {
        mWetL = v;
        Q_EMIT wetLChanged();
      }
    }

    Q_PROPERTY(double wetL READ wetL WRITE setWetL NOTIFY wetLChanged)
    Q_PROPERTY(bool isWetLImmutable READ isWetLImmutable CONSTANT)
    Q_PROPERTY(double defaultWetLValue READ defaultWetLValue CONSTANT)
    /**
      Get wetL
    */
    double wetL() const
    {
      return mWetL;
    }

    /**
      Is wetL Immutable
    */
    bool isWetLImmutable() const
    {
      return isImmutable( QStringLiteral( "wetL" ) );
    }

    /**
      Get wetL default value
    */
    double defaultWetLValue() const
    {
        return defaultWetLValue_helper();
    }

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

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

      if (v != mWetR && !isWetRImmutable()) {
        mWetR = v;
        Q_EMIT wetRChanged();
      }
    }

    Q_PROPERTY(double wetR READ wetR WRITE setWetR NOTIFY wetRChanged)
    Q_PROPERTY(bool isWetRImmutable READ isWetRImmutable CONSTANT)
    Q_PROPERTY(double defaultWetRValue READ defaultWetRValue CONSTANT)
    /**
      Get wetR
    */
    double wetR() const
    {
      return mWetR;
    }

    /**
      Is wetR Immutable
    */
    bool isWetRImmutable() const
    {
      return isImmutable( QStringLiteral( "wetR" ) );
    }

    /**
      Get wetR default value
    */
    double defaultWetRValue() const
    {
        return defaultWetRValue_helper();
    }

    /**
      Set modeLLabels
    */
    void setModeLLabels( const QStringList & v )
    {
      if (v != mModeLLabels && !isModeLLabelsImmutable()) {
        mModeLLabels = v;
        Q_EMIT modeLLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList modeLLabels READ modeLLabels WRITE setModeLLabels NOTIFY modeLLabelsChanged)
    Q_PROPERTY(bool isModeLLabelsImmutable READ isModeLLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultModeLLabelsValue READ defaultModeLLabelsValue CONSTANT)
    /**
      Get modeLLabels
    */
    QStringList modeLLabels() const
    {
      return mModeLLabels;
    }

    /**
      Is modeLLabels Immutable
    */
    bool isModeLLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "modeLLabels" ) );
    }

    /**
      Get modeLLabels default value
    */
    QStringList defaultModeLLabelsValue() const
    {
        return defaultModeLLabelsValue_helper();
    }

    /**
      Set Left Channel Mode
    */
    void setModeL( int v )
    {
      if (v != mModeL && !isModeLImmutable()) {
        mModeL = v;
        Q_EMIT modeLChanged();
      }
    }

    Q_PROPERTY(int modeL READ modeL WRITE setModeL NOTIFY modeLChanged)
    Q_PROPERTY(bool isModeLImmutable READ isModeLImmutable CONSTANT)
    Q_PROPERTY(int defaultModeLValue READ defaultModeLValue CONSTANT)
    /**
      Get Left Channel Mode
    */
    int modeL() const
    {
      return mModeL;
    }

    /**
      Is Left Channel Mode Immutable
    */
    bool isModeLImmutable() const
    {
      return isImmutable( QStringLiteral( "modeL" ) );
    }

    /**
      Get Left Channel Mode default value
    */
    int defaultModeLValue() const
    {
        return defaultModeLValue_helper();
    }

    /**
      Set modeRLabels
    */
    void setModeRLabels( const QStringList & v )
    {
      if (v != mModeRLabels && !isModeRLabelsImmutable()) {
        mModeRLabels = v;
        Q_EMIT modeRLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList modeRLabels READ modeRLabels WRITE setModeRLabels NOTIFY modeRLabelsChanged)
    Q_PROPERTY(bool isModeRLabelsImmutable READ isModeRLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultModeRLabelsValue READ defaultModeRLabelsValue CONSTANT)
    /**
      Get modeRLabels
    */
    QStringList modeRLabels() const
    {
      return mModeRLabels;
    }

    /**
      Is modeRLabels Immutable
    */
    bool isModeRLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "modeRLabels" ) );
    }

    /**
      Get modeRLabels default value
    */
    QStringList defaultModeRLabelsValue() const
    {
        return defaultModeRLabelsValue_helper();
    }

    /**
      Set Right Channel Mode
    */
    void setModeR( int v )
    {
      if (v != mModeR && !isModeRImmutable()) {
        mModeR = v;
        Q_EMIT modeRChanged();
      }
    }

    Q_PROPERTY(int modeR READ modeR WRITE setModeR NOTIFY modeRChanged)
    Q_PROPERTY(bool isModeRImmutable READ isModeRImmutable CONSTANT)
    Q_PROPERTY(int defaultModeRValue READ defaultModeRValue CONSTANT)
    /**
      Get Right Channel Mode
    */
    int modeR() const
    {
      return mModeR;
    }

    /**
      Is Right Channel Mode Immutable
    */
    bool isModeRImmutable() const
    {
      return isImmutable( QStringLiteral( "modeR" ) );
    }

    /**
      Get Right Channel Mode default value
    */
    int defaultModeRValue() const
    {
        return defaultModeRValue_helper();
    }

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

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

      if (v != mTimeL && !isTimeLImmutable()) {
        mTimeL = v;
        Q_EMIT timeLChanged();
      }
    }

    Q_PROPERTY(double timeL READ timeL WRITE setTimeL NOTIFY timeLChanged)
    Q_PROPERTY(bool isTimeLImmutable READ isTimeLImmutable CONSTANT)
    Q_PROPERTY(double defaultTimeLValue READ defaultTimeLValue CONSTANT)
    /**
      Get timeL
    */
    double timeL() const
    {
      return mTimeL;
    }

    /**
      Is timeL Immutable
    */
    bool isTimeLImmutable() const
    {
      return isImmutable( QStringLiteral( "timeL" ) );
    }

    /**
      Get timeL default value
    */
    double defaultTimeLValue() const
    {
        return defaultTimeLValue_helper();
    }

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

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

      if (v != mTimeR && !isTimeRImmutable()) {
        mTimeR = v;
        Q_EMIT timeRChanged();
      }
    }

    Q_PROPERTY(double timeR READ timeR WRITE setTimeR NOTIFY timeRChanged)
    Q_PROPERTY(bool isTimeRImmutable READ isTimeRImmutable CONSTANT)
    Q_PROPERTY(double defaultTimeRValue READ defaultTimeRValue CONSTANT)
    /**
      Get timeR
    */
    double timeR() const
    {
      return mTimeR;
    }

    /**
      Is timeR Immutable
    */
    bool isTimeRImmutable() const
    {
      return isImmutable( QStringLiteral( "timeR" ) );
    }

    /**
      Get timeR default value
    */
    double defaultTimeRValue() const
    {
        return defaultTimeRValue_helper();
    }

    /**
      Set invertPhaseL
    */
    void setInvertPhaseL( bool v )
    {
      if (v != mInvertPhaseL && !isInvertPhaseLImmutable()) {
        mInvertPhaseL = v;
        Q_EMIT invertPhaseLChanged();
      }
    }

    Q_PROPERTY(bool invertPhaseL READ invertPhaseL WRITE setInvertPhaseL NOTIFY invertPhaseLChanged)
    Q_PROPERTY(bool isInvertPhaseLImmutable READ isInvertPhaseLImmutable CONSTANT)
    Q_PROPERTY(bool defaultInvertPhaseLValue READ defaultInvertPhaseLValue CONSTANT)
    /**
      Get invertPhaseL
    */
    bool invertPhaseL() const
    {
      return mInvertPhaseL;
    }

    /**
      Is invertPhaseL Immutable
    */
    bool isInvertPhaseLImmutable() const
    {
      return isImmutable( QStringLiteral( "invertPhaseL" ) );
    }

    /**
      Get invertPhaseL default value
    */
    bool defaultInvertPhaseLValue() const
    {
        return defaultInvertPhaseLValue_helper();
    }

    /**
      Set invertPhaseR
    */
    void setInvertPhaseR( bool v )
    {
      if (v != mInvertPhaseR && !isInvertPhaseRImmutable()) {
        mInvertPhaseR = v;
        Q_EMIT invertPhaseRChanged();
      }
    }

    Q_PROPERTY(bool invertPhaseR READ invertPhaseR WRITE setInvertPhaseR NOTIFY invertPhaseRChanged)
    Q_PROPERTY(bool isInvertPhaseRImmutable READ isInvertPhaseRImmutable CONSTANT)
    Q_PROPERTY(bool defaultInvertPhaseRValue READ defaultInvertPhaseRValue CONSTANT)
    /**
      Get invertPhaseR
    */
    bool invertPhaseR() const
    {
      return mInvertPhaseR;
    }

    /**
      Is invertPhaseR Immutable
    */
    bool isInvertPhaseRImmutable() const
    {
      return isImmutable( QStringLiteral( "invertPhaseR" ) );
    }

    /**
      Get invertPhaseR default value
    */
    bool defaultInvertPhaseRValue() const
    {
        return defaultInvertPhaseRValue_helper();
    }

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

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

      if (v != mSampleL && !isSampleLImmutable()) {
        mSampleL = v;
        Q_EMIT sampleLChanged();
      }
    }

    Q_PROPERTY(double sampleL READ sampleL WRITE setSampleL NOTIFY sampleLChanged)
    Q_PROPERTY(bool isSampleLImmutable READ isSampleLImmutable CONSTANT)
    Q_PROPERTY(double defaultSampleLValue READ defaultSampleLValue CONSTANT)
    /**
      Get sampleL
    */
    double sampleL() const
    {
      return mSampleL;
    }

    /**
      Is sampleL Immutable
    */
    bool isSampleLImmutable() const
    {
      return isImmutable( QStringLiteral( "sampleL" ) );
    }

    /**
      Get sampleL default value
    */
    double defaultSampleLValue() const
    {
        return defaultSampleLValue_helper();
    }

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

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

      if (v != mSampleR && !isSampleRImmutable()) {
        mSampleR = v;
        Q_EMIT sampleRChanged();
      }
    }

    Q_PROPERTY(double sampleR READ sampleR WRITE setSampleR NOTIFY sampleRChanged)
    Q_PROPERTY(bool isSampleRImmutable READ isSampleRImmutable CONSTANT)
    Q_PROPERTY(double defaultSampleRValue READ defaultSampleRValue CONSTANT)
    /**
      Get sampleR
    */
    double sampleR() const
    {
      return mSampleR;
    }

    /**
      Is sampleR Immutable
    */
    bool isSampleRImmutable() const
    {
      return isImmutable( QStringLiteral( "sampleR" ) );
    }

    /**
      Get sampleR default value
    */
    double defaultSampleRValue() const
    {
        return defaultSampleRValue_helper();
    }

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

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

      if (v != mMetersL && !isMetersLImmutable()) {
        mMetersL = v;
        Q_EMIT metersLChanged();
      }
    }

    Q_PROPERTY(double metersL READ metersL WRITE setMetersL NOTIFY metersLChanged)
    Q_PROPERTY(bool isMetersLImmutable READ isMetersLImmutable CONSTANT)
    Q_PROPERTY(double defaultMetersLValue READ defaultMetersLValue CONSTANT)
    /**
      Get metersL
    */
    double metersL() const
    {
      return mMetersL;
    }

    /**
      Is metersL Immutable
    */
    bool isMetersLImmutable() const
    {
      return isImmutable( QStringLiteral( "metersL" ) );
    }

    /**
      Get metersL default value
    */
    double defaultMetersLValue() const
    {
        return defaultMetersLValue_helper();
    }

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

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

      if (v != mMetersR && !isMetersRImmutable()) {
        mMetersR = v;
        Q_EMIT metersRChanged();
      }
    }

    Q_PROPERTY(double metersR READ metersR WRITE setMetersR NOTIFY metersRChanged)
    Q_PROPERTY(bool isMetersRImmutable READ isMetersRImmutable CONSTANT)
    Q_PROPERTY(double defaultMetersRValue READ defaultMetersRValue CONSTANT)
    /**
      Get metersR
    */
    double metersR() const
    {
      return mMetersR;
    }

    /**
      Is metersR Immutable
    */
    bool isMetersRImmutable() const
    {
      return isImmutable( QStringLiteral( "metersR" ) );
    }

    /**
      Get metersR default value
    */
    double defaultMetersRValue() const
    {
        return defaultMetersRValue_helper();
    }

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

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

      if (v != mCentimetersL && !isCentimetersLImmutable()) {
        mCentimetersL = v;
        Q_EMIT centimetersLChanged();
      }
    }

    Q_PROPERTY(double centimetersL READ centimetersL WRITE setCentimetersL NOTIFY centimetersLChanged)
    Q_PROPERTY(bool isCentimetersLImmutable READ isCentimetersLImmutable CONSTANT)
    Q_PROPERTY(double defaultCentimetersLValue READ defaultCentimetersLValue CONSTANT)
    /**
      Get centimetersL
    */
    double centimetersL() const
    {
      return mCentimetersL;
    }

    /**
      Is centimetersL Immutable
    */
    bool isCentimetersLImmutable() const
    {
      return isImmutable( QStringLiteral( "centimetersL" ) );
    }

    /**
      Get centimetersL default value
    */
    double defaultCentimetersLValue() const
    {
        return defaultCentimetersLValue_helper();
    }

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

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

      if (v != mCentimetersR && !isCentimetersRImmutable()) {
        mCentimetersR = v;
        Q_EMIT centimetersRChanged();
      }
    }

    Q_PROPERTY(double centimetersR READ centimetersR WRITE setCentimetersR NOTIFY centimetersRChanged)
    Q_PROPERTY(bool isCentimetersRImmutable READ isCentimetersRImmutable CONSTANT)
    Q_PROPERTY(double defaultCentimetersRValue READ defaultCentimetersRValue CONSTANT)
    /**
      Get centimetersR
    */
    double centimetersR() const
    {
      return mCentimetersR;
    }

    /**
      Is centimetersR Immutable
    */
    bool isCentimetersRImmutable() const
    {
      return isImmutable( QStringLiteral( "centimetersR" ) );
    }

    /**
      Get centimetersR default value
    */
    double defaultCentimetersRValue() const
    {
        return defaultCentimetersRValue_helper();
    }

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

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

      if (v != mTemperatureL && !isTemperatureLImmutable()) {
        mTemperatureL = v;
        Q_EMIT temperatureLChanged();
      }
    }

    Q_PROPERTY(double temperatureL READ temperatureL WRITE setTemperatureL NOTIFY temperatureLChanged)
    Q_PROPERTY(bool isTemperatureLImmutable READ isTemperatureLImmutable CONSTANT)
    Q_PROPERTY(double defaultTemperatureLValue READ defaultTemperatureLValue CONSTANT)
    /**
      Get temperatureL
    */
    double temperatureL() const
    {
      return mTemperatureL;
    }

    /**
      Is temperatureL Immutable
    */
    bool isTemperatureLImmutable() const
    {
      return isImmutable( QStringLiteral( "temperatureL" ) );
    }

    /**
      Get temperatureL default value
    */
    double defaultTemperatureLValue() const
    {
        return defaultTemperatureLValue_helper();
    }

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

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

      if (v != mTemperatureR && !isTemperatureRImmutable()) {
        mTemperatureR = v;
        Q_EMIT temperatureRChanged();
      }
    }

    Q_PROPERTY(double temperatureR READ temperatureR WRITE setTemperatureR NOTIFY temperatureRChanged)
    Q_PROPERTY(bool isTemperatureRImmutable READ isTemperatureRImmutable CONSTANT)
    Q_PROPERTY(double defaultTemperatureRValue READ defaultTemperatureRValue CONSTANT)
    /**
      Get temperatureR
    */
    double temperatureR() const
    {
      return mTemperatureR;
    }

    /**
      Is temperatureR Immutable
    */
    bool isTemperatureRImmutable() const
    {
      return isImmutable( QStringLiteral( "temperatureR" ) );
    }

    /**
      Get temperatureR default value
    */
    double defaultTemperatureRValue() const
    {
        return defaultTemperatureRValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalDryLChanged = 4,
      signalDryRChanged = 5,
      signalWetLChanged = 6,
      signalWetRChanged = 7,
      signalModeLLabelsChanged = 8,
      signalModeLChanged = 9,
      signalModeRLabelsChanged = 10,
      signalModeRChanged = 11,
      signalTimeLChanged = 12,
      signalTimeRChanged = 13,
      signalInvertPhaseLChanged = 14,
      signalInvertPhaseRChanged = 15,
      signalSampleLChanged = 16,
      signalSampleRChanged = 17,
      signalMetersLChanged = 18,
      signalMetersRChanged = 19,
      signalCentimetersLChanged = 20,
      signalCentimetersRChanged = 21,
      signalTemperatureLChanged = 22,
      signalTemperatureRChanged = 23
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void dryLChanged();

    void dryRChanged();

    void wetLChanged();

    void wetRChanged();

    void modeLLabelsChanged();

    void modeLChanged();

    void modeRLabelsChanged();

    void modeRChanged();

    void timeLChanged();

    void timeRChanged();

    void invertPhaseLChanged();

    void invertPhaseRChanged();

    void sampleLChanged();

    void sampleRChanged();

    void metersLChanged();

    void metersRChanged();

    void centimetersLChanged();

    void centimetersRChanged();

    void temperatureLChanged();

    void temperatureRChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // Delay#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    double mDryL;
    double defaultDryLValue_helper() const;
    double mDryR;
    double defaultDryRValue_helper() const;
    double mWetL;
    double defaultWetLValue_helper() const;
    double mWetR;
    double defaultWetRValue_helper() const;
    QStringList mModeLLabels;
    QStringList defaultModeLLabelsValue_helper() const;
    int mModeL;
    int defaultModeLValue_helper() const;
    QStringList mModeRLabels;
    QStringList defaultModeRLabelsValue_helper() const;
    int mModeR;
    int defaultModeRValue_helper() const;
    double mTimeL;
    double defaultTimeLValue_helper() const;
    double mTimeR;
    double defaultTimeRValue_helper() const;
    bool mInvertPhaseL;
    bool defaultInvertPhaseLValue_helper() const;
    bool mInvertPhaseR;
    bool defaultInvertPhaseRValue_helper() const;
    double mSampleL;
    double defaultSampleLValue_helper() const;
    double mSampleR;
    double defaultSampleRValue_helper() const;
    double mMetersL;
    double defaultMetersLValue_helper() const;
    double mMetersR;
    double defaultMetersRValue_helper() const;
    double mCentimetersL;
    double defaultCentimetersLValue_helper() const;
    double mCentimetersR;
    double defaultCentimetersRValue_helper() const;
    double mTemperatureL;
    double defaultTemperatureLValue_helper() const;
    double mTemperatureR;
    double defaultTemperatureRValue_helper() const;
};

#endif

