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

#include "kconfig_base_ee.hpp"

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

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

    DbLimiter( const QString & masterGroup, const QString & instanceIndex );
    ~DbLimiter() 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 oversamplingLabels
    */
    void setOversamplingLabels( const QStringList & v )
    {
      if (v != mOversamplingLabels && !isOversamplingLabelsImmutable()) {
        mOversamplingLabels = v;
        Q_EMIT oversamplingLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList oversamplingLabels READ oversamplingLabels WRITE setOversamplingLabels NOTIFY oversamplingLabelsChanged)
    Q_PROPERTY(bool isOversamplingLabelsImmutable READ isOversamplingLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultOversamplingLabelsValue READ defaultOversamplingLabelsValue CONSTANT)
    /**
      Get oversamplingLabels
    */
    QStringList oversamplingLabels() const
    {
      return mOversamplingLabels;
    }

    /**
      Is oversamplingLabels Immutable
    */
    bool isOversamplingLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "oversamplingLabels" ) );
    }

    /**
      Get oversamplingLabels default value
    */
    QStringList defaultOversamplingLabelsValue() const
    {
        return defaultOversamplingLabelsValue_helper();
    }

    /**
      Set Oversampling
    */
    void setOversampling( int v )
    {
      if (v != mOversampling && !isOversamplingImmutable()) {
        mOversampling = v;
        Q_EMIT oversamplingChanged();
      }
    }

    Q_PROPERTY(int oversampling READ oversampling WRITE setOversampling NOTIFY oversamplingChanged)
    Q_PROPERTY(bool isOversamplingImmutable READ isOversamplingImmutable CONSTANT)
    Q_PROPERTY(int defaultOversamplingValue READ defaultOversamplingValue CONSTANT)
    /**
      Get Oversampling
    */
    int oversampling() const
    {
      return mOversampling;
    }

    /**
      Is Oversampling Immutable
    */
    bool isOversamplingImmutable() const
    {
      return isImmutable( QStringLiteral( "oversampling" ) );
    }

    /**
      Get Oversampling default value
    */
    int defaultOversamplingValue() const
    {
        return defaultOversamplingValue_helper();
    }

    /**
      Set ditheringLabels
    */
    void setDitheringLabels( const QStringList & v )
    {
      if (v != mDitheringLabels && !isDitheringLabelsImmutable()) {
        mDitheringLabels = v;
        Q_EMIT ditheringLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList ditheringLabels READ ditheringLabels WRITE setDitheringLabels NOTIFY ditheringLabelsChanged)
    Q_PROPERTY(bool isDitheringLabelsImmutable READ isDitheringLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultDitheringLabelsValue READ defaultDitheringLabelsValue CONSTANT)
    /**
      Get ditheringLabels
    */
    QStringList ditheringLabels() const
    {
      return mDitheringLabels;
    }

    /**
      Is ditheringLabels Immutable
    */
    bool isDitheringLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "ditheringLabels" ) );
    }

    /**
      Get ditheringLabels default value
    */
    QStringList defaultDitheringLabelsValue() const
    {
        return defaultDitheringLabelsValue_helper();
    }

    /**
      Set Dithering
    */
    void setDithering( int v )
    {
      if (v != mDithering && !isDitheringImmutable()) {
        mDithering = v;
        Q_EMIT ditheringChanged();
      }
    }

    Q_PROPERTY(int dithering READ dithering WRITE setDithering NOTIFY ditheringChanged)
    Q_PROPERTY(bool isDitheringImmutable READ isDitheringImmutable CONSTANT)
    Q_PROPERTY(int defaultDitheringValue READ defaultDitheringValue CONSTANT)
    /**
      Get Dithering
    */
    int dithering() const
    {
      return mDithering;
    }

    /**
      Is Dithering Immutable
    */
    bool isDitheringImmutable() const
    {
      return isImmutable( QStringLiteral( "dithering" ) );
    }

    /**
      Get Dithering default value
    */
    int defaultDitheringValue() const
    {
        return defaultDitheringValue_helper();
    }

    /**
      Set sidechainTypeLabels
    */
    void setSidechainTypeLabels( const QStringList & v )
    {
      if (v != mSidechainTypeLabels && !isSidechainTypeLabelsImmutable()) {
        mSidechainTypeLabels = v;
        Q_EMIT sidechainTypeLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList sidechainTypeLabels READ sidechainTypeLabels WRITE setSidechainTypeLabels NOTIFY sidechainTypeLabelsChanged)
    Q_PROPERTY(bool isSidechainTypeLabelsImmutable READ isSidechainTypeLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultSidechainTypeLabelsValue READ defaultSidechainTypeLabelsValue CONSTANT)
    /**
      Get sidechainTypeLabels
    */
    QStringList sidechainTypeLabels() const
    {
      return mSidechainTypeLabels;
    }

    /**
      Is sidechainTypeLabels Immutable
    */
    bool isSidechainTypeLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainTypeLabels" ) );
    }

    /**
      Get sidechainTypeLabels default value
    */
    QStringList defaultSidechainTypeLabelsValue() const
    {
        return defaultSidechainTypeLabelsValue_helper();
    }

    /**
      Set Sidechain type
    */
    void setSidechainType( int v )
    {
      if (v != mSidechainType && !isSidechainTypeImmutable()) {
        mSidechainType = v;
        Q_EMIT sidechainTypeChanged();
      }
    }

    Q_PROPERTY(int sidechainType READ sidechainType WRITE setSidechainType NOTIFY sidechainTypeChanged)
    Q_PROPERTY(bool isSidechainTypeImmutable READ isSidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultSidechainTypeValue READ defaultSidechainTypeValue CONSTANT)
    /**
      Get Sidechain type
    */
    int sidechainType() const
    {
      return mSidechainType;
    }

    /**
      Is Sidechain type Immutable
    */
    bool isSidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainType" ) );
    }

    /**
      Get Sidechain type default value
    */
    int defaultSidechainTypeValue() const
    {
        return defaultSidechainTypeValue_helper();
    }

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

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

      if (v != mLookahead && !isLookaheadImmutable()) {
        mLookahead = v;
        Q_EMIT lookaheadChanged();
      }
    }

    Q_PROPERTY(double lookahead READ lookahead WRITE setLookahead NOTIFY lookaheadChanged)
    Q_PROPERTY(bool isLookaheadImmutable READ isLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultLookaheadValue READ defaultLookaheadValue CONSTANT)
    /**
      Get lookahead
    */
    double lookahead() const
    {
      return mLookahead;
    }

    /**
      Is lookahead Immutable
    */
    bool isLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "lookahead" ) );
    }

    /**
      Get lookahead default value
    */
    double defaultLookaheadValue() const
    {
        return defaultLookaheadValue_helper();
    }

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

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

      if (v != mAttack && !isAttackImmutable()) {
        mAttack = v;
        Q_EMIT attackChanged();
      }
    }

    Q_PROPERTY(double attack READ attack WRITE setAttack NOTIFY attackChanged)
    Q_PROPERTY(bool isAttackImmutable READ isAttackImmutable CONSTANT)
    Q_PROPERTY(double defaultAttackValue READ defaultAttackValue CONSTANT)
    /**
      Get attack
    */
    double attack() const
    {
      return mAttack;
    }

    /**
      Is attack Immutable
    */
    bool isAttackImmutable() const
    {
      return isImmutable( QStringLiteral( "attack" ) );
    }

    /**
      Get attack default value
    */
    double defaultAttackValue() const
    {
        return defaultAttackValue_helper();
    }

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

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

      if (v != mRelease && !isReleaseImmutable()) {
        mRelease = v;
        Q_EMIT releaseChanged();
      }
    }

    Q_PROPERTY(double release READ release WRITE setRelease NOTIFY releaseChanged)
    Q_PROPERTY(bool isReleaseImmutable READ isReleaseImmutable CONSTANT)
    Q_PROPERTY(double defaultReleaseValue READ defaultReleaseValue CONSTANT)
    /**
      Get release
    */
    double release() const
    {
      return mRelease;
    }

    /**
      Is release Immutable
    */
    bool isReleaseImmutable() const
    {
      return isImmutable( QStringLiteral( "release" ) );
    }

    /**
      Get release default value
    */
    double defaultReleaseValue() const
    {
        return defaultReleaseValue_helper();
    }

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

      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 gainBoost
    */
    void setGainBoost( bool v )
    {
      if (v != mGainBoost && !isGainBoostImmutable()) {
        mGainBoost = v;
        Q_EMIT gainBoostChanged();
      }
    }

    Q_PROPERTY(bool gainBoost READ gainBoost WRITE setGainBoost NOTIFY gainBoostChanged)
    Q_PROPERTY(bool isGainBoostImmutable READ isGainBoostImmutable CONSTANT)
    Q_PROPERTY(bool defaultGainBoostValue READ defaultGainBoostValue CONSTANT)
    /**
      Get gainBoost
    */
    bool gainBoost() const
    {
      return mGainBoost;
    }

    /**
      Is gainBoost Immutable
    */
    bool isGainBoostImmutable() const
    {
      return isImmutable( QStringLiteral( "gainBoost" ) );
    }

    /**
      Get gainBoost default value
    */
    bool defaultGainBoostValue() const
    {
        return defaultGainBoostValue_helper();
    }

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

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

      if (v != mSidechainPreamp && !isSidechainPreampImmutable()) {
        mSidechainPreamp = v;
        Q_EMIT sidechainPreampChanged();
      }
    }

    Q_PROPERTY(double sidechainPreamp READ sidechainPreamp WRITE setSidechainPreamp NOTIFY sidechainPreampChanged)
    Q_PROPERTY(bool isSidechainPreampImmutable READ isSidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultSidechainPreampValue READ defaultSidechainPreampValue CONSTANT)
    /**
      Get sidechainPreamp
    */
    double sidechainPreamp() const
    {
      return mSidechainPreamp;
    }

    /**
      Is sidechainPreamp Immutable
    */
    bool isSidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainPreamp" ) );
    }

    /**
      Get sidechainPreamp default value
    */
    double defaultSidechainPreampValue() const
    {
        return defaultSidechainPreampValue_helper();
    }

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

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

      if (v != mStereoLink && !isStereoLinkImmutable()) {
        mStereoLink = v;
        Q_EMIT stereoLinkChanged();
      }
    }

    Q_PROPERTY(double stereoLink READ stereoLink WRITE setStereoLink NOTIFY stereoLinkChanged)
    Q_PROPERTY(bool isStereoLinkImmutable READ isStereoLinkImmutable CONSTANT)
    Q_PROPERTY(double defaultStereoLinkValue READ defaultStereoLinkValue CONSTANT)
    /**
      Get stereoLink
    */
    double stereoLink() const
    {
      return mStereoLink;
    }

    /**
      Is stereoLink Immutable
    */
    bool isStereoLinkImmutable() const
    {
      return isImmutable( QStringLiteral( "stereoLink" ) );
    }

    /**
      Get stereoLink default value
    */
    double defaultStereoLinkValue() const
    {
        return defaultStereoLinkValue_helper();
    }

    /**
      Set alr
    */
    void setAlr( bool v )
    {
      if (v != mAlr && !isAlrImmutable()) {
        mAlr = v;
        Q_EMIT alrChanged();
      }
    }

    Q_PROPERTY(bool alr READ alr WRITE setAlr NOTIFY alrChanged)
    Q_PROPERTY(bool isAlrImmutable READ isAlrImmutable CONSTANT)
    Q_PROPERTY(bool defaultAlrValue READ defaultAlrValue CONSTANT)
    /**
      Get alr
    */
    bool alr() const
    {
      return mAlr;
    }

    /**
      Is alr Immutable
    */
    bool isAlrImmutable() const
    {
      return isImmutable( QStringLiteral( "alr" ) );
    }

    /**
      Get alr default value
    */
    bool defaultAlrValue() const
    {
        return defaultAlrValue_helper();
    }

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

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

      if (v != mAlrAttack && !isAlrAttackImmutable()) {
        mAlrAttack = v;
        Q_EMIT alrAttackChanged();
      }
    }

    Q_PROPERTY(double alrAttack READ alrAttack WRITE setAlrAttack NOTIFY alrAttackChanged)
    Q_PROPERTY(bool isAlrAttackImmutable READ isAlrAttackImmutable CONSTANT)
    Q_PROPERTY(double defaultAlrAttackValue READ defaultAlrAttackValue CONSTANT)
    /**
      Get alrAttack
    */
    double alrAttack() const
    {
      return mAlrAttack;
    }

    /**
      Is alrAttack Immutable
    */
    bool isAlrAttackImmutable() const
    {
      return isImmutable( QStringLiteral( "alrAttack" ) );
    }

    /**
      Get alrAttack default value
    */
    double defaultAlrAttackValue() const
    {
        return defaultAlrAttackValue_helper();
    }

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

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

      if (v != mAlrRelease && !isAlrReleaseImmutable()) {
        mAlrRelease = v;
        Q_EMIT alrReleaseChanged();
      }
    }

    Q_PROPERTY(double alrRelease READ alrRelease WRITE setAlrRelease NOTIFY alrReleaseChanged)
    Q_PROPERTY(bool isAlrReleaseImmutable READ isAlrReleaseImmutable CONSTANT)
    Q_PROPERTY(double defaultAlrReleaseValue READ defaultAlrReleaseValue CONSTANT)
    /**
      Get alrRelease
    */
    double alrRelease() const
    {
      return mAlrRelease;
    }

    /**
      Is alrRelease Immutable
    */
    bool isAlrReleaseImmutable() const
    {
      return isImmutable( QStringLiteral( "alrRelease" ) );
    }

    /**
      Get alrRelease default value
    */
    double defaultAlrReleaseValue() const
    {
        return defaultAlrReleaseValue_helper();
    }

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

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

      if (v != mAlrKnee && !isAlrKneeImmutable()) {
        mAlrKnee = v;
        Q_EMIT alrKneeChanged();
      }
    }

    Q_PROPERTY(double alrKnee READ alrKnee WRITE setAlrKnee NOTIFY alrKneeChanged)
    Q_PROPERTY(bool isAlrKneeImmutable READ isAlrKneeImmutable CONSTANT)
    Q_PROPERTY(double defaultAlrKneeValue READ defaultAlrKneeValue CONSTANT)
    /**
      Get alrKnee
    */
    double alrKnee() const
    {
      return mAlrKnee;
    }

    /**
      Is alrKnee Immutable
    */
    bool isAlrKneeImmutable() const
    {
      return isImmutable( QStringLiteral( "alrKnee" ) );
    }

    /**
      Get alrKnee default value
    */
    double defaultAlrKneeValue() const
    {
        return defaultAlrKneeValue_helper();
    }

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

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

      if (v != mAlrKneeSmooth && !isAlrKneeSmoothImmutable()) {
        mAlrKneeSmooth = v;
        Q_EMIT alrKneeSmoothChanged();
      }
    }

    Q_PROPERTY(double alrKneeSmooth READ alrKneeSmooth WRITE setAlrKneeSmooth NOTIFY alrKneeSmoothChanged)
    Q_PROPERTY(bool isAlrKneeSmoothImmutable READ isAlrKneeSmoothImmutable CONSTANT)
    Q_PROPERTY(double defaultAlrKneeSmoothValue READ defaultAlrKneeSmoothValue CONSTANT)
    /**
      Get alrKneeSmooth
    */
    double alrKneeSmooth() const
    {
      return mAlrKneeSmooth;
    }

    /**
      Is alrKneeSmooth Immutable
    */
    bool isAlrKneeSmoothImmutable() const
    {
      return isImmutable( QStringLiteral( "alrKneeSmooth" ) );
    }

    /**
      Get alrKneeSmooth default value
    */
    double defaultAlrKneeSmoothValue() const
    {
        return defaultAlrKneeSmoothValue_helper();
    }

    /**
      Set sidechainInputDevice
    */
    void setSidechainInputDevice( const QString & v )
    {
      if (v != mSidechainInputDevice && !isSidechainInputDeviceImmutable()) {
        mSidechainInputDevice = v;
        Q_EMIT sidechainInputDeviceChanged();
      }
    }

    Q_PROPERTY(QString sidechainInputDevice READ sidechainInputDevice WRITE setSidechainInputDevice NOTIFY sidechainInputDeviceChanged)
    Q_PROPERTY(bool isSidechainInputDeviceImmutable READ isSidechainInputDeviceImmutable CONSTANT)
    Q_PROPERTY(QString defaultSidechainInputDeviceValue READ defaultSidechainInputDeviceValue CONSTANT)
    /**
      Get sidechainInputDevice
    */
    QString sidechainInputDevice() const
    {
      return mSidechainInputDevice;
    }

    /**
      Is sidechainInputDevice Immutable
    */
    bool isSidechainInputDeviceImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainInputDevice" ) );
    }

    /**
      Get sidechainInputDevice default value
    */
    QString defaultSidechainInputDeviceValue() const
    {
        return defaultSidechainInputDeviceValue_helper();
    }

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

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

      if (v != mInputToSidechain && !isInputToSidechainImmutable()) {
        mInputToSidechain = v;
        Q_EMIT inputToSidechainChanged();
      }
    }

    Q_PROPERTY(double inputToSidechain READ inputToSidechain WRITE setInputToSidechain NOTIFY inputToSidechainChanged)
    Q_PROPERTY(bool isInputToSidechainImmutable READ isInputToSidechainImmutable CONSTANT)
    Q_PROPERTY(double defaultInputToSidechainValue READ defaultInputToSidechainValue CONSTANT)
    /**
      Get inputToSidechain
    */
    double inputToSidechain() const
    {
      return mInputToSidechain;
    }

    /**
      Is inputToSidechain Immutable
    */
    bool isInputToSidechainImmutable() const
    {
      return isImmutable( QStringLiteral( "inputToSidechain" ) );
    }

    /**
      Get inputToSidechain default value
    */
    double defaultInputToSidechainValue() const
    {
        return defaultInputToSidechainValue_helper();
    }

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

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

      if (v != mInputToLink && !isInputToLinkImmutable()) {
        mInputToLink = v;
        Q_EMIT inputToLinkChanged();
      }
    }

    Q_PROPERTY(double inputToLink READ inputToLink WRITE setInputToLink NOTIFY inputToLinkChanged)
    Q_PROPERTY(bool isInputToLinkImmutable READ isInputToLinkImmutable CONSTANT)
    Q_PROPERTY(double defaultInputToLinkValue READ defaultInputToLinkValue CONSTANT)
    /**
      Get inputToLink
    */
    double inputToLink() const
    {
      return mInputToLink;
    }

    /**
      Is inputToLink Immutable
    */
    bool isInputToLinkImmutable() const
    {
      return isImmutable( QStringLiteral( "inputToLink" ) );
    }

    /**
      Get inputToLink default value
    */
    double defaultInputToLinkValue() const
    {
        return defaultInputToLinkValue_helper();
    }

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

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

      if (v != mSidechainToInput && !isSidechainToInputImmutable()) {
        mSidechainToInput = v;
        Q_EMIT sidechainToInputChanged();
      }
    }

    Q_PROPERTY(double sidechainToInput READ sidechainToInput WRITE setSidechainToInput NOTIFY sidechainToInputChanged)
    Q_PROPERTY(bool isSidechainToInputImmutable READ isSidechainToInputImmutable CONSTANT)
    Q_PROPERTY(double defaultSidechainToInputValue READ defaultSidechainToInputValue CONSTANT)
    /**
      Get sidechainToInput
    */
    double sidechainToInput() const
    {
      return mSidechainToInput;
    }

    /**
      Is sidechainToInput Immutable
    */
    bool isSidechainToInputImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainToInput" ) );
    }

    /**
      Get sidechainToInput default value
    */
    double defaultSidechainToInputValue() const
    {
        return defaultSidechainToInputValue_helper();
    }

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

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

      if (v != mSidechainToLink && !isSidechainToLinkImmutable()) {
        mSidechainToLink = v;
        Q_EMIT sidechainToLinkChanged();
      }
    }

    Q_PROPERTY(double sidechainToLink READ sidechainToLink WRITE setSidechainToLink NOTIFY sidechainToLinkChanged)
    Q_PROPERTY(bool isSidechainToLinkImmutable READ isSidechainToLinkImmutable CONSTANT)
    Q_PROPERTY(double defaultSidechainToLinkValue READ defaultSidechainToLinkValue CONSTANT)
    /**
      Get sidechainToLink
    */
    double sidechainToLink() const
    {
      return mSidechainToLink;
    }

    /**
      Is sidechainToLink Immutable
    */
    bool isSidechainToLinkImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainToLink" ) );
    }

    /**
      Get sidechainToLink default value
    */
    double defaultSidechainToLinkValue() const
    {
        return defaultSidechainToLinkValue_helper();
    }

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

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

      if (v != mLinkToSidechain && !isLinkToSidechainImmutable()) {
        mLinkToSidechain = v;
        Q_EMIT linkToSidechainChanged();
      }
    }

    Q_PROPERTY(double linkToSidechain READ linkToSidechain WRITE setLinkToSidechain NOTIFY linkToSidechainChanged)
    Q_PROPERTY(bool isLinkToSidechainImmutable READ isLinkToSidechainImmutable CONSTANT)
    Q_PROPERTY(double defaultLinkToSidechainValue READ defaultLinkToSidechainValue CONSTANT)
    /**
      Get linkToSidechain
    */
    double linkToSidechain() const
    {
      return mLinkToSidechain;
    }

    /**
      Is linkToSidechain Immutable
    */
    bool isLinkToSidechainImmutable() const
    {
      return isImmutable( QStringLiteral( "linkToSidechain" ) );
    }

    /**
      Get linkToSidechain default value
    */
    double defaultLinkToSidechainValue() const
    {
        return defaultLinkToSidechainValue_helper();
    }

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

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

      if (v != mLinkToInput && !isLinkToInputImmutable()) {
        mLinkToInput = v;
        Q_EMIT linkToInputChanged();
      }
    }

    Q_PROPERTY(double linkToInput READ linkToInput WRITE setLinkToInput NOTIFY linkToInputChanged)
    Q_PROPERTY(bool isLinkToInputImmutable READ isLinkToInputImmutable CONSTANT)
    Q_PROPERTY(double defaultLinkToInputValue READ defaultLinkToInputValue CONSTANT)
    /**
      Get linkToInput
    */
    double linkToInput() const
    {
      return mLinkToInput;
    }

    /**
      Is linkToInput Immutable
    */
    bool isLinkToInputImmutable() const
    {
      return isImmutable( QStringLiteral( "linkToInput" ) );
    }

    /**
      Get linkToInput default value
    */
    double defaultLinkToInputValue() const
    {
        return defaultLinkToInputValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalModeLabelsChanged = 4,
      signalModeChanged = 5,
      signalOversamplingLabelsChanged = 6,
      signalOversamplingChanged = 7,
      signalDitheringLabelsChanged = 8,
      signalDitheringChanged = 9,
      signalSidechainTypeLabelsChanged = 10,
      signalSidechainTypeChanged = 11,
      signalLookaheadChanged = 12,
      signalAttackChanged = 13,
      signalReleaseChanged = 14,
      signalThresholdChanged = 15,
      signalGainBoostChanged = 16,
      signalSidechainPreampChanged = 17,
      signalStereoLinkChanged = 18,
      signalAlrChanged = 19,
      signalAlrAttackChanged = 20,
      signalAlrReleaseChanged = 21,
      signalAlrKneeChanged = 22,
      signalAlrKneeSmoothChanged = 23,
      signalSidechainInputDeviceChanged = 24,
      signalInputToSidechainChanged = 25,
      signalInputToLinkChanged = 26,
      signalSidechainToInputChanged = 27,
      signalSidechainToLinkChanged = 28,
      signalLinkToSidechainChanged = 29,
      signalLinkToInputChanged = 30
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void modeLabelsChanged();

    void modeChanged();

    void oversamplingLabelsChanged();

    void oversamplingChanged();

    void ditheringLabelsChanged();

    void ditheringChanged();

    void sidechainTypeLabelsChanged();

    void sidechainTypeChanged();

    void lookaheadChanged();

    void attackChanged();

    void releaseChanged();

    void thresholdChanged();

    void gainBoostChanged();

    void sidechainPreampChanged();

    void stereoLinkChanged();

    void alrChanged();

    void alrAttackChanged();

    void alrReleaseChanged();

    void alrKneeChanged();

    void alrKneeSmoothChanged();

    void sidechainInputDeviceChanged();

    void inputToSidechainChanged();

    void inputToLinkChanged();

    void sidechainToInputChanged();

    void sidechainToLinkChanged();

    void linkToSidechainChanged();

    void linkToInputChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // Limiter#$(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;
    QStringList mOversamplingLabels;
    QStringList defaultOversamplingLabelsValue_helper() const;
    int mOversampling;
    int defaultOversamplingValue_helper() const;
    QStringList mDitheringLabels;
    QStringList defaultDitheringLabelsValue_helper() const;
    int mDithering;
    int defaultDitheringValue_helper() const;
    QStringList mSidechainTypeLabels;
    QStringList defaultSidechainTypeLabelsValue_helper() const;
    int mSidechainType;
    int defaultSidechainTypeValue_helper() const;
    double mLookahead;
    double defaultLookaheadValue_helper() const;
    double mAttack;
    double defaultAttackValue_helper() const;
    double mRelease;
    double defaultReleaseValue_helper() const;
    double mThreshold;
    double defaultThresholdValue_helper() const;
    bool mGainBoost;
    bool defaultGainBoostValue_helper() const;
    double mSidechainPreamp;
    double defaultSidechainPreampValue_helper() const;
    double mStereoLink;
    double defaultStereoLinkValue_helper() const;
    bool mAlr;
    bool defaultAlrValue_helper() const;
    double mAlrAttack;
    double defaultAlrAttackValue_helper() const;
    double mAlrRelease;
    double defaultAlrReleaseValue_helper() const;
    double mAlrKnee;
    double defaultAlrKneeValue_helper() const;
    double mAlrKneeSmooth;
    double defaultAlrKneeSmoothValue_helper() const;
    QString mSidechainInputDevice;
    QString defaultSidechainInputDeviceValue_helper() const;
    double mInputToSidechain;
    double defaultInputToSidechainValue_helper() const;
    double mInputToLink;
    double defaultInputToLinkValue_helper() const;
    double mSidechainToInput;
    double defaultSidechainToInputValue_helper() const;
    double mSidechainToLink;
    double defaultSidechainToLinkValue_helper() const;
    double mLinkToSidechain;
    double defaultLinkToSidechainValue_helper() const;
    double mLinkToInput;
    double defaultLinkToInputValue_helper() const;
};

#endif

