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

#include "kconfig_base_ee.hpp"

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

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

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

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

      if (v != mBalanceIn && !isBalanceInImmutable()) {
        mBalanceIn = v;
        Q_EMIT balanceInChanged();
      }
    }

    Q_PROPERTY(double balanceIn READ balanceIn WRITE setBalanceIn NOTIFY balanceInChanged)
    Q_PROPERTY(bool isBalanceInImmutable READ isBalanceInImmutable CONSTANT)
    Q_PROPERTY(double defaultBalanceInValue READ defaultBalanceInValue CONSTANT)
    /**
      Get balanceIn
    */
    double balanceIn() const
    {
      return mBalanceIn;
    }

    /**
      Is balanceIn Immutable
    */
    bool isBalanceInImmutable() const
    {
      return isImmutable( QStringLiteral( "balanceIn" ) );
    }

    /**
      Get balanceIn default value
    */
    double defaultBalanceInValue() const
    {
        return defaultBalanceInValue_helper();
    }

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

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

      if (v != mBalanceOut && !isBalanceOutImmutable()) {
        mBalanceOut = v;
        Q_EMIT balanceOutChanged();
      }
    }

    Q_PROPERTY(double balanceOut READ balanceOut WRITE setBalanceOut NOTIFY balanceOutChanged)
    Q_PROPERTY(bool isBalanceOutImmutable READ isBalanceOutImmutable CONSTANT)
    Q_PROPERTY(double defaultBalanceOutValue READ defaultBalanceOutValue CONSTANT)
    /**
      Get balanceOut
    */
    double balanceOut() const
    {
      return mBalanceOut;
    }

    /**
      Is balanceOut Immutable
    */
    bool isBalanceOutImmutable() const
    {
      return isImmutable( QStringLiteral( "balanceOut" ) );
    }

    /**
      Get balanceOut default value
    */
    double defaultBalanceOutValue() const
    {
        return defaultBalanceOutValue_helper();
    }

    /**
      Set softclip
    */
    void setSoftclip( bool v )
    {
      if (v != mSoftclip && !isSoftclipImmutable()) {
        mSoftclip = v;
        Q_EMIT softclipChanged();
      }
    }

    Q_PROPERTY(bool softclip READ softclip WRITE setSoftclip NOTIFY softclipChanged)
    Q_PROPERTY(bool isSoftclipImmutable READ isSoftclipImmutable CONSTANT)
    Q_PROPERTY(bool defaultSoftclipValue READ defaultSoftclipValue CONSTANT)
    /**
      Get softclip
    */
    bool softclip() const
    {
      return mSoftclip;
    }

    /**
      Is softclip Immutable
    */
    bool isSoftclipImmutable() const
    {
      return isImmutable( QStringLiteral( "softclip" ) );
    }

    /**
      Get softclip default value
    */
    bool defaultSoftclipValue() const
    {
        return defaultSoftclipValue_helper();
    }

    /**
      Set mutel
    */
    void setMutel( bool v )
    {
      if (v != mMutel && !isMutelImmutable()) {
        mMutel = v;
        Q_EMIT mutelChanged();
      }
    }

    Q_PROPERTY(bool mutel READ mutel WRITE setMutel NOTIFY mutelChanged)
    Q_PROPERTY(bool isMutelImmutable READ isMutelImmutable CONSTANT)
    Q_PROPERTY(bool defaultMutelValue READ defaultMutelValue CONSTANT)
    /**
      Get mutel
    */
    bool mutel() const
    {
      return mMutel;
    }

    /**
      Is mutel Immutable
    */
    bool isMutelImmutable() const
    {
      return isImmutable( QStringLiteral( "mutel" ) );
    }

    /**
      Get mutel default value
    */
    bool defaultMutelValue() const
    {
        return defaultMutelValue_helper();
    }

    /**
      Set muter
    */
    void setMuter( bool v )
    {
      if (v != mMuter && !isMuterImmutable()) {
        mMuter = v;
        Q_EMIT muterChanged();
      }
    }

    Q_PROPERTY(bool muter READ muter WRITE setMuter NOTIFY muterChanged)
    Q_PROPERTY(bool isMuterImmutable READ isMuterImmutable CONSTANT)
    Q_PROPERTY(bool defaultMuterValue READ defaultMuterValue CONSTANT)
    /**
      Get muter
    */
    bool muter() const
    {
      return mMuter;
    }

    /**
      Is muter Immutable
    */
    bool isMuterImmutable() const
    {
      return isImmutable( QStringLiteral( "muter" ) );
    }

    /**
      Get muter default value
    */
    bool defaultMuterValue() const
    {
        return defaultMuterValue_helper();
    }

    /**
      Set phasel
    */
    void setPhasel( bool v )
    {
      if (v != mPhasel && !isPhaselImmutable()) {
        mPhasel = v;
        Q_EMIT phaselChanged();
      }
    }

    Q_PROPERTY(bool phasel READ phasel WRITE setPhasel NOTIFY phaselChanged)
    Q_PROPERTY(bool isPhaselImmutable READ isPhaselImmutable CONSTANT)
    Q_PROPERTY(bool defaultPhaselValue READ defaultPhaselValue CONSTANT)
    /**
      Get phasel
    */
    bool phasel() const
    {
      return mPhasel;
    }

    /**
      Is phasel Immutable
    */
    bool isPhaselImmutable() const
    {
      return isImmutable( QStringLiteral( "phasel" ) );
    }

    /**
      Get phasel default value
    */
    bool defaultPhaselValue() const
    {
        return defaultPhaselValue_helper();
    }

    /**
      Set phaser
    */
    void setPhaser( bool v )
    {
      if (v != mPhaser && !isPhaserImmutable()) {
        mPhaser = v;
        Q_EMIT phaserChanged();
      }
    }

    Q_PROPERTY(bool phaser READ phaser WRITE setPhaser NOTIFY phaserChanged)
    Q_PROPERTY(bool isPhaserImmutable READ isPhaserImmutable CONSTANT)
    Q_PROPERTY(bool defaultPhaserValue READ defaultPhaserValue CONSTANT)
    /**
      Get phaser
    */
    bool phaser() const
    {
      return mPhaser;
    }

    /**
      Is phaser Immutable
    */
    bool isPhaserImmutable() const
    {
      return isImmutable( QStringLiteral( "phaser" ) );
    }

    /**
      Get phaser default value
    */
    bool defaultPhaserValue() const
    {
        return defaultPhaserValue_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 slev
    */
    void setSlev( double v )
    {
      if (v < -36)
      {
        qDebug() << "setSlev: value " << v << " is less than the minimum value of -36";
        v = -36;
      }

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

      if (v != mSlev && !isSlevImmutable()) {
        mSlev = v;
        Q_EMIT slevChanged();
      }
    }

    Q_PROPERTY(double slev READ slev WRITE setSlev NOTIFY slevChanged)
    Q_PROPERTY(bool isSlevImmutable READ isSlevImmutable CONSTANT)
    Q_PROPERTY(double defaultSlevValue READ defaultSlevValue CONSTANT)
    /**
      Get slev
    */
    double slev() const
    {
      return mSlev;
    }

    /**
      Is slev Immutable
    */
    bool isSlevImmutable() const
    {
      return isImmutable( QStringLiteral( "slev" ) );
    }

    /**
      Get slev default value
    */
    double defaultSlevValue() const
    {
        return defaultSlevValue_helper();
    }

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

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

      if (v != mSbal && !isSbalImmutable()) {
        mSbal = v;
        Q_EMIT sbalChanged();
      }
    }

    Q_PROPERTY(double sbal READ sbal WRITE setSbal NOTIFY sbalChanged)
    Q_PROPERTY(bool isSbalImmutable READ isSbalImmutable CONSTANT)
    Q_PROPERTY(double defaultSbalValue READ defaultSbalValue CONSTANT)
    /**
      Get sbal
    */
    double sbal() const
    {
      return mSbal;
    }

    /**
      Is sbal Immutable
    */
    bool isSbalImmutable() const
    {
      return isImmutable( QStringLiteral( "sbal" ) );
    }

    /**
      Get sbal default value
    */
    double defaultSbalValue() const
    {
        return defaultSbalValue_helper();
    }

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

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

      if (v != mMlev && !isMlevImmutable()) {
        mMlev = v;
        Q_EMIT mlevChanged();
      }
    }

    Q_PROPERTY(double mlev READ mlev WRITE setMlev NOTIFY mlevChanged)
    Q_PROPERTY(bool isMlevImmutable READ isMlevImmutable CONSTANT)
    Q_PROPERTY(double defaultMlevValue READ defaultMlevValue CONSTANT)
    /**
      Get mlev
    */
    double mlev() const
    {
      return mMlev;
    }

    /**
      Is mlev Immutable
    */
    bool isMlevImmutable() const
    {
      return isImmutable( QStringLiteral( "mlev" ) );
    }

    /**
      Get mlev default value
    */
    double defaultMlevValue() const
    {
        return defaultMlevValue_helper();
    }

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

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

      if (v != mMpan && !isMpanImmutable()) {
        mMpan = v;
        Q_EMIT mpanChanged();
      }
    }

    Q_PROPERTY(double mpan READ mpan WRITE setMpan NOTIFY mpanChanged)
    Q_PROPERTY(bool isMpanImmutable READ isMpanImmutable CONSTANT)
    Q_PROPERTY(double defaultMpanValue READ defaultMpanValue CONSTANT)
    /**
      Get mpan
    */
    double mpan() const
    {
      return mMpan;
    }

    /**
      Is mpan Immutable
    */
    bool isMpanImmutable() const
    {
      return isImmutable( QStringLiteral( "mpan" ) );
    }

    /**
      Get mpan default value
    */
    double defaultMpanValue() const
    {
        return defaultMpanValue_helper();
    }

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

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

      if (v != mStereoBase && !isStereoBaseImmutable()) {
        mStereoBase = v;
        Q_EMIT stereoBaseChanged();
      }
    }

    Q_PROPERTY(double stereoBase READ stereoBase WRITE setStereoBase NOTIFY stereoBaseChanged)
    Q_PROPERTY(bool isStereoBaseImmutable READ isStereoBaseImmutable CONSTANT)
    Q_PROPERTY(double defaultStereoBaseValue READ defaultStereoBaseValue CONSTANT)
    /**
      Get stereoBase
    */
    double stereoBase() const
    {
      return mStereoBase;
    }

    /**
      Is stereoBase Immutable
    */
    bool isStereoBaseImmutable() const
    {
      return isImmutable( QStringLiteral( "stereoBase" ) );
    }

    /**
      Get stereoBase default value
    */
    double defaultStereoBaseValue() const
    {
        return defaultStereoBaseValue_helper();
    }

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

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

      if (v != mDelay && !isDelayImmutable()) {
        mDelay = v;
        Q_EMIT delayChanged();
      }
    }

    Q_PROPERTY(double delay READ delay WRITE setDelay NOTIFY delayChanged)
    Q_PROPERTY(bool isDelayImmutable READ isDelayImmutable CONSTANT)
    Q_PROPERTY(double defaultDelayValue READ defaultDelayValue CONSTANT)
    /**
      Get delay
    */
    double delay() const
    {
      return mDelay;
    }

    /**
      Is delay Immutable
    */
    bool isDelayImmutable() const
    {
      return isImmutable( QStringLiteral( "delay" ) );
    }

    /**
      Get delay default value
    */
    double defaultDelayValue() const
    {
        return defaultDelayValue_helper();
    }

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

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

      if (v != mScLevel && !isScLevelImmutable()) {
        mScLevel = v;
        Q_EMIT scLevelChanged();
      }
    }

    Q_PROPERTY(double scLevel READ scLevel WRITE setScLevel NOTIFY scLevelChanged)
    Q_PROPERTY(bool isScLevelImmutable READ isScLevelImmutable CONSTANT)
    Q_PROPERTY(double defaultScLevelValue READ defaultScLevelValue CONSTANT)
    /**
      Get scLevel
    */
    double scLevel() const
    {
      return mScLevel;
    }

    /**
      Is scLevel Immutable
    */
    bool isScLevelImmutable() const
    {
      return isImmutable( QStringLiteral( "scLevel" ) );
    }

    /**
      Get scLevel default value
    */
    double defaultScLevelValue() const
    {
        return defaultScLevelValue_helper();
    }

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

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

      if (v != mStereoPhase && !isStereoPhaseImmutable()) {
        mStereoPhase = v;
        Q_EMIT stereoPhaseChanged();
      }
    }

    Q_PROPERTY(double stereoPhase READ stereoPhase WRITE setStereoPhase NOTIFY stereoPhaseChanged)
    Q_PROPERTY(bool isStereoPhaseImmutable READ isStereoPhaseImmutable CONSTANT)
    Q_PROPERTY(double defaultStereoPhaseValue READ defaultStereoPhaseValue CONSTANT)
    /**
      Get stereoPhase
    */
    double stereoPhase() const
    {
      return mStereoPhase;
    }

    /**
      Is stereoPhase Immutable
    */
    bool isStereoPhaseImmutable() const
    {
      return isImmutable( QStringLiteral( "stereoPhase" ) );
    }

    /**
      Get stereoPhase default value
    */
    double defaultStereoPhaseValue() const
    {
        return defaultStereoPhaseValue_helper();
    }

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

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

      if (v != mDry && !isDryImmutable()) {
        mDry = v;
        Q_EMIT dryChanged();
      }
    }

    Q_PROPERTY(double dry READ dry WRITE setDry NOTIFY dryChanged)
    Q_PROPERTY(bool isDryImmutable READ isDryImmutable CONSTANT)
    Q_PROPERTY(double defaultDryValue READ defaultDryValue CONSTANT)
    /**
      Get dry
    */
    double dry() const
    {
      return mDry;
    }

    /**
      Is dry Immutable
    */
    bool isDryImmutable() const
    {
      return isImmutable( QStringLiteral( "dry" ) );
    }

    /**
      Get dry default value
    */
    double defaultDryValue() const
    {
        return defaultDryValue_helper();
    }

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

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

      if (v != mWet && !isWetImmutable()) {
        mWet = v;
        Q_EMIT wetChanged();
      }
    }

    Q_PROPERTY(double wet READ wet WRITE setWet NOTIFY wetChanged)
    Q_PROPERTY(bool isWetImmutable READ isWetImmutable CONSTANT)
    Q_PROPERTY(double defaultWetValue READ defaultWetValue CONSTANT)
    /**
      Get wet
    */
    double wet() const
    {
      return mWet;
    }

    /**
      Is wet Immutable
    */
    bool isWetImmutable() const
    {
      return isImmutable( QStringLiteral( "wet" ) );
    }

    /**
      Get wet default value
    */
    double defaultWetValue() const
    {
        return defaultWetValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalBalanceInChanged = 4,
      signalBalanceOutChanged = 5,
      signalSoftclipChanged = 6,
      signalMutelChanged = 7,
      signalMuterChanged = 8,
      signalPhaselChanged = 9,
      signalPhaserChanged = 10,
      signalModeLabelsChanged = 11,
      signalModeChanged = 12,
      signalSlevChanged = 13,
      signalSbalChanged = 14,
      signalMlevChanged = 15,
      signalMpanChanged = 16,
      signalStereoBaseChanged = 17,
      signalDelayChanged = 18,
      signalScLevelChanged = 19,
      signalStereoPhaseChanged = 20,
      signalDryChanged = 21,
      signalWetChanged = 22
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void balanceInChanged();

    void balanceOutChanged();

    void softclipChanged();

    void mutelChanged();

    void muterChanged();

    void phaselChanged();

    void phaserChanged();

    void modeLabelsChanged();

    void modeChanged();

    void slevChanged();

    void sbalChanged();

    void mlevChanged();

    void mpanChanged();

    void stereoBaseChanged();

    void delayChanged();

    void scLevelChanged();

    void stereoPhaseChanged();

    void dryChanged();

    void wetChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // StereoTools#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    double mBalanceIn;
    double defaultBalanceInValue_helper() const;
    double mBalanceOut;
    double defaultBalanceOutValue_helper() const;
    bool mSoftclip;
    bool defaultSoftclipValue_helper() const;
    bool mMutel;
    bool defaultMutelValue_helper() const;
    bool mMuter;
    bool defaultMuterValue_helper() const;
    bool mPhasel;
    bool defaultPhaselValue_helper() const;
    bool mPhaser;
    bool defaultPhaserValue_helper() const;
    QStringList mModeLabels;
    QStringList defaultModeLabelsValue_helper() const;
    int mMode;
    int defaultModeValue_helper() const;
    double mSlev;
    double defaultSlevValue_helper() const;
    double mSbal;
    double defaultSbalValue_helper() const;
    double mMlev;
    double defaultMlevValue_helper() const;
    double mMpan;
    double defaultMpanValue_helper() const;
    double mStereoBase;
    double defaultStereoBaseValue_helper() const;
    double mDelay;
    double defaultDelayValue_helper() const;
    double mScLevel;
    double defaultScLevelValue_helper() const;
    double mStereoPhase;
    double defaultStereoPhaseValue_helper() const;
    double mDry;
    double defaultDryValue_helper() const;
    double mWet;
    double defaultWetValue_helper() const;
};

#endif

