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

#include "kconfig_base_ee.hpp"

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

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

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

      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 < -80.01)
      {
        qDebug() << "setWet: value " << v << " is less than the minimum value of -80.01";
        v = -80.01;
      }

      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();
    }

    /**
      Set viewSidechain
    */
    void setViewSidechain( bool v )
    {
      if (v != mViewSidechain && !isViewSidechainImmutable()) {
        mViewSidechain = v;
        Q_EMIT viewSidechainChanged();
      }
    }

    Q_PROPERTY(bool viewSidechain READ viewSidechain WRITE setViewSidechain NOTIFY viewSidechainChanged)
    Q_PROPERTY(bool isViewSidechainImmutable READ isViewSidechainImmutable CONSTANT)
    Q_PROPERTY(bool defaultViewSidechainValue READ defaultViewSidechainValue CONSTANT)
    /**
      Get viewSidechain
    */
    bool viewSidechain() const
    {
      return mViewSidechain;
    }

    /**
      Is viewSidechain Immutable
    */
    bool isViewSidechainImmutable() const
    {
      return isImmutable( QStringLiteral( "viewSidechain" ) );
    }

    /**
      Get viewSidechain default value
    */
    bool defaultViewSidechainValue() const
    {
        return defaultViewSidechainValue_helper();
    }

    /**
      Set externalSidechainEnabled
    */
    void setExternalSidechainEnabled( bool v )
    {
      if (v != mExternalSidechainEnabled && !isExternalSidechainEnabledImmutable()) {
        mExternalSidechainEnabled = v;
        Q_EMIT externalSidechainEnabledChanged();
      }
    }

    Q_PROPERTY(bool externalSidechainEnabled READ externalSidechainEnabled WRITE setExternalSidechainEnabled NOTIFY externalSidechainEnabledChanged)
    Q_PROPERTY(bool isExternalSidechainEnabledImmutable READ isExternalSidechainEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultExternalSidechainEnabledValue READ defaultExternalSidechainEnabledValue CONSTANT)
    /**
      Get externalSidechainEnabled
    */
    bool externalSidechainEnabled() const
    {
      return mExternalSidechainEnabled;
    }

    /**
      Is externalSidechainEnabled Immutable
    */
    bool isExternalSidechainEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "externalSidechainEnabled" ) );
    }

    /**
      Get externalSidechainEnabled default value
    */
    bool defaultExternalSidechainEnabledValue() const
    {
        return defaultExternalSidechainEnabledValue_helper();
    }

    /**
      Set stereoSplit
    */
    void setStereoSplit( bool v )
    {
      if (v != mStereoSplit && !isStereoSplitImmutable()) {
        mStereoSplit = v;
        Q_EMIT stereoSplitChanged();
      }
    }

    Q_PROPERTY(bool stereoSplit READ stereoSplit WRITE setStereoSplit NOTIFY stereoSplitChanged)
    Q_PROPERTY(bool isStereoSplitImmutable READ isStereoSplitImmutable CONSTANT)
    Q_PROPERTY(bool defaultStereoSplitValue READ defaultStereoSplitValue CONSTANT)
    /**
      Get stereoSplit
    */
    bool stereoSplit() const
    {
      return mStereoSplit;
    }

    /**
      Is stereoSplit Immutable
    */
    bool isStereoSplitImmutable() const
    {
      return isImmutable( QStringLiteral( "stereoSplit" ) );
    }

    /**
      Get stereoSplit default value
    */
    bool defaultStereoSplitValue() const
    {
        return defaultStereoSplitValue_helper();
    }

    /**
      Set compressorModeLabels
    */
    void setCompressorModeLabels( const QStringList & v )
    {
      if (v != mCompressorModeLabels && !isCompressorModeLabelsImmutable()) {
        mCompressorModeLabels = v;
        Q_EMIT compressorModeLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList compressorModeLabels READ compressorModeLabels WRITE setCompressorModeLabels NOTIFY compressorModeLabelsChanged)
    Q_PROPERTY(bool isCompressorModeLabelsImmutable READ isCompressorModeLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultCompressorModeLabelsValue READ defaultCompressorModeLabelsValue CONSTANT)
    /**
      Get compressorModeLabels
    */
    QStringList compressorModeLabels() const
    {
      return mCompressorModeLabels;
    }

    /**
      Is compressorModeLabels Immutable
    */
    bool isCompressorModeLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "compressorModeLabels" ) );
    }

    /**
      Get compressorModeLabels default value
    */
    QStringList defaultCompressorModeLabelsValue() const
    {
        return defaultCompressorModeLabelsValue_helper();
    }

    /**
      Set compressorMode
    */
    void setCompressorMode( int v )
    {
      if (v != mCompressorMode && !isCompressorModeImmutable()) {
        mCompressorMode = v;
        Q_EMIT compressorModeChanged();
      }
    }

    Q_PROPERTY(int compressorMode READ compressorMode WRITE setCompressorMode NOTIFY compressorModeChanged)
    Q_PROPERTY(bool isCompressorModeImmutable READ isCompressorModeImmutable CONSTANT)
    Q_PROPERTY(int defaultCompressorModeValue READ defaultCompressorModeValue CONSTANT)
    /**
      Get compressorMode
    */
    int compressorMode() const
    {
      return mCompressorMode;
    }

    /**
      Is compressorMode Immutable
    */
    bool isCompressorModeImmutable() const
    {
      return isImmutable( QStringLiteral( "compressorMode" ) );
    }

    /**
      Get compressorMode default value
    */
    int defaultCompressorModeValue() const
    {
        return defaultCompressorModeValue_helper();
    }

    /**
      Set envelopeBoostLabels
    */
    void setEnvelopeBoostLabels( const QStringList & v )
    {
      if (v != mEnvelopeBoostLabels && !isEnvelopeBoostLabelsImmutable()) {
        mEnvelopeBoostLabels = v;
        Q_EMIT envelopeBoostLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList envelopeBoostLabels READ envelopeBoostLabels WRITE setEnvelopeBoostLabels NOTIFY envelopeBoostLabelsChanged)
    Q_PROPERTY(bool isEnvelopeBoostLabelsImmutable READ isEnvelopeBoostLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultEnvelopeBoostLabelsValue READ defaultEnvelopeBoostLabelsValue CONSTANT)
    /**
      Get envelopeBoostLabels
    */
    QStringList envelopeBoostLabels() const
    {
      return mEnvelopeBoostLabels;
    }

    /**
      Is envelopeBoostLabels Immutable
    */
    bool isEnvelopeBoostLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "envelopeBoostLabels" ) );
    }

    /**
      Get envelopeBoostLabels default value
    */
    QStringList defaultEnvelopeBoostLabelsValue() const
    {
        return defaultEnvelopeBoostLabelsValue_helper();
    }

    /**
      Set envelopeBoost
    */
    void setEnvelopeBoost( int v )
    {
      if (v != mEnvelopeBoost && !isEnvelopeBoostImmutable()) {
        mEnvelopeBoost = v;
        Q_EMIT envelopeBoostChanged();
      }
    }

    Q_PROPERTY(int envelopeBoost READ envelopeBoost WRITE setEnvelopeBoost NOTIFY envelopeBoostChanged)
    Q_PROPERTY(bool isEnvelopeBoostImmutable READ isEnvelopeBoostImmutable CONSTANT)
    Q_PROPERTY(int defaultEnvelopeBoostValue READ defaultEnvelopeBoostValue CONSTANT)
    /**
      Get envelopeBoost
    */
    int envelopeBoost() const
    {
      return mEnvelopeBoost;
    }

    /**
      Is envelopeBoost Immutable
    */
    bool isEnvelopeBoostImmutable() const
    {
      return isImmutable( QStringLiteral( "envelopeBoost" ) );
    }

    /**
      Get envelopeBoost default value
    */
    int defaultEnvelopeBoostValue() const
    {
        return defaultEnvelopeBoostValue_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();
    }

    /**
      Set band1Enable
    */
    void setBand1Enable( bool v )
    {
      if (v != mBand1Enable && !isBand1EnableImmutable()) {
        mBand1Enable = v;
        Q_EMIT band1EnableChanged();
      }
    }

    Q_PROPERTY(bool band1Enable READ band1Enable WRITE setBand1Enable NOTIFY band1EnableChanged)
    Q_PROPERTY(bool isBand1EnableImmutable READ isBand1EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand1EnableValue READ defaultBand1EnableValue CONSTANT)
    /**
      Get band1Enable
    */
    bool band1Enable() const
    {
      return mBand1Enable;
    }

    /**
      Is band1Enable Immutable
    */
    bool isBand1EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band1Enable" ) );
    }

    /**
      Get band1Enable default value
    */
    bool defaultBand1EnableValue() const
    {
        return defaultBand1EnableValue_helper();
    }

    /**
      Set band2Enable
    */
    void setBand2Enable( bool v )
    {
      if (v != mBand2Enable && !isBand2EnableImmutable()) {
        mBand2Enable = v;
        Q_EMIT band2EnableChanged();
      }
    }

    Q_PROPERTY(bool band2Enable READ band2Enable WRITE setBand2Enable NOTIFY band2EnableChanged)
    Q_PROPERTY(bool isBand2EnableImmutable READ isBand2EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand2EnableValue READ defaultBand2EnableValue CONSTANT)
    /**
      Get band2Enable
    */
    bool band2Enable() const
    {
      return mBand2Enable;
    }

    /**
      Is band2Enable Immutable
    */
    bool isBand2EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band2Enable" ) );
    }

    /**
      Get band2Enable default value
    */
    bool defaultBand2EnableValue() const
    {
        return defaultBand2EnableValue_helper();
    }

    /**
      Set band3Enable
    */
    void setBand3Enable( bool v )
    {
      if (v != mBand3Enable && !isBand3EnableImmutable()) {
        mBand3Enable = v;
        Q_EMIT band3EnableChanged();
      }
    }

    Q_PROPERTY(bool band3Enable READ band3Enable WRITE setBand3Enable NOTIFY band3EnableChanged)
    Q_PROPERTY(bool isBand3EnableImmutable READ isBand3EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand3EnableValue READ defaultBand3EnableValue CONSTANT)
    /**
      Get band3Enable
    */
    bool band3Enable() const
    {
      return mBand3Enable;
    }

    /**
      Is band3Enable Immutable
    */
    bool isBand3EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band3Enable" ) );
    }

    /**
      Get band3Enable default value
    */
    bool defaultBand3EnableValue() const
    {
        return defaultBand3EnableValue_helper();
    }

    /**
      Set band4Enable
    */
    void setBand4Enable( bool v )
    {
      if (v != mBand4Enable && !isBand4EnableImmutable()) {
        mBand4Enable = v;
        Q_EMIT band4EnableChanged();
      }
    }

    Q_PROPERTY(bool band4Enable READ band4Enable WRITE setBand4Enable NOTIFY band4EnableChanged)
    Q_PROPERTY(bool isBand4EnableImmutable READ isBand4EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand4EnableValue READ defaultBand4EnableValue CONSTANT)
    /**
      Get band4Enable
    */
    bool band4Enable() const
    {
      return mBand4Enable;
    }

    /**
      Is band4Enable Immutable
    */
    bool isBand4EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band4Enable" ) );
    }

    /**
      Get band4Enable default value
    */
    bool defaultBand4EnableValue() const
    {
        return defaultBand4EnableValue_helper();
    }

    /**
      Set band5Enable
    */
    void setBand5Enable( bool v )
    {
      if (v != mBand5Enable && !isBand5EnableImmutable()) {
        mBand5Enable = v;
        Q_EMIT band5EnableChanged();
      }
    }

    Q_PROPERTY(bool band5Enable READ band5Enable WRITE setBand5Enable NOTIFY band5EnableChanged)
    Q_PROPERTY(bool isBand5EnableImmutable READ isBand5EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand5EnableValue READ defaultBand5EnableValue CONSTANT)
    /**
      Get band5Enable
    */
    bool band5Enable() const
    {
      return mBand5Enable;
    }

    /**
      Is band5Enable Immutable
    */
    bool isBand5EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band5Enable" ) );
    }

    /**
      Get band5Enable default value
    */
    bool defaultBand5EnableValue() const
    {
        return defaultBand5EnableValue_helper();
    }

    /**
      Set band6Enable
    */
    void setBand6Enable( bool v )
    {
      if (v != mBand6Enable && !isBand6EnableImmutable()) {
        mBand6Enable = v;
        Q_EMIT band6EnableChanged();
      }
    }

    Q_PROPERTY(bool band6Enable READ band6Enable WRITE setBand6Enable NOTIFY band6EnableChanged)
    Q_PROPERTY(bool isBand6EnableImmutable READ isBand6EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand6EnableValue READ defaultBand6EnableValue CONSTANT)
    /**
      Get band6Enable
    */
    bool band6Enable() const
    {
      return mBand6Enable;
    }

    /**
      Is band6Enable Immutable
    */
    bool isBand6EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band6Enable" ) );
    }

    /**
      Get band6Enable default value
    */
    bool defaultBand6EnableValue() const
    {
        return defaultBand6EnableValue_helper();
    }

    /**
      Set band7Enable
    */
    void setBand7Enable( bool v )
    {
      if (v != mBand7Enable && !isBand7EnableImmutable()) {
        mBand7Enable = v;
        Q_EMIT band7EnableChanged();
      }
    }

    Q_PROPERTY(bool band7Enable READ band7Enable WRITE setBand7Enable NOTIFY band7EnableChanged)
    Q_PROPERTY(bool isBand7EnableImmutable READ isBand7EnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand7EnableValue READ defaultBand7EnableValue CONSTANT)
    /**
      Get band7Enable
    */
    bool band7Enable() const
    {
      return mBand7Enable;
    }

    /**
      Is band7Enable Immutable
    */
    bool isBand7EnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band7Enable" ) );
    }

    /**
      Get band7Enable default value
    */
    bool defaultBand7EnableValue() const
    {
        return defaultBand7EnableValue_helper();
    }

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

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

      if (v != mBand1SplitFrequency && !isBand1SplitFrequencyImmutable()) {
        mBand1SplitFrequency = v;
        Q_EMIT band1SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band1SplitFrequency READ band1SplitFrequency WRITE setBand1SplitFrequency NOTIFY band1SplitFrequencyChanged)
    Q_PROPERTY(bool isBand1SplitFrequencyImmutable READ isBand1SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1SplitFrequencyValue READ defaultBand1SplitFrequencyValue CONSTANT)
    /**
      Get band1SplitFrequency
    */
    double band1SplitFrequency() const
    {
      return mBand1SplitFrequency;
    }

    /**
      Is band1SplitFrequency Immutable
    */
    bool isBand1SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SplitFrequency" ) );
    }

    /**
      Get band1SplitFrequency default value
    */
    double defaultBand1SplitFrequencyValue() const
    {
        return defaultBand1SplitFrequencyValue_helper();
    }

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

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

      if (v != mBand2SplitFrequency && !isBand2SplitFrequencyImmutable()) {
        mBand2SplitFrequency = v;
        Q_EMIT band2SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band2SplitFrequency READ band2SplitFrequency WRITE setBand2SplitFrequency NOTIFY band2SplitFrequencyChanged)
    Q_PROPERTY(bool isBand2SplitFrequencyImmutable READ isBand2SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2SplitFrequencyValue READ defaultBand2SplitFrequencyValue CONSTANT)
    /**
      Get band2SplitFrequency
    */
    double band2SplitFrequency() const
    {
      return mBand2SplitFrequency;
    }

    /**
      Is band2SplitFrequency Immutable
    */
    bool isBand2SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SplitFrequency" ) );
    }

    /**
      Get band2SplitFrequency default value
    */
    double defaultBand2SplitFrequencyValue() const
    {
        return defaultBand2SplitFrequencyValue_helper();
    }

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

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

      if (v != mBand3SplitFrequency && !isBand3SplitFrequencyImmutable()) {
        mBand3SplitFrequency = v;
        Q_EMIT band3SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band3SplitFrequency READ band3SplitFrequency WRITE setBand3SplitFrequency NOTIFY band3SplitFrequencyChanged)
    Q_PROPERTY(bool isBand3SplitFrequencyImmutable READ isBand3SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3SplitFrequencyValue READ defaultBand3SplitFrequencyValue CONSTANT)
    /**
      Get band3SplitFrequency
    */
    double band3SplitFrequency() const
    {
      return mBand3SplitFrequency;
    }

    /**
      Is band3SplitFrequency Immutable
    */
    bool isBand3SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SplitFrequency" ) );
    }

    /**
      Get band3SplitFrequency default value
    */
    double defaultBand3SplitFrequencyValue() const
    {
        return defaultBand3SplitFrequencyValue_helper();
    }

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

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

      if (v != mBand4SplitFrequency && !isBand4SplitFrequencyImmutable()) {
        mBand4SplitFrequency = v;
        Q_EMIT band4SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band4SplitFrequency READ band4SplitFrequency WRITE setBand4SplitFrequency NOTIFY band4SplitFrequencyChanged)
    Q_PROPERTY(bool isBand4SplitFrequencyImmutable READ isBand4SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4SplitFrequencyValue READ defaultBand4SplitFrequencyValue CONSTANT)
    /**
      Get band4SplitFrequency
    */
    double band4SplitFrequency() const
    {
      return mBand4SplitFrequency;
    }

    /**
      Is band4SplitFrequency Immutable
    */
    bool isBand4SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SplitFrequency" ) );
    }

    /**
      Get band4SplitFrequency default value
    */
    double defaultBand4SplitFrequencyValue() const
    {
        return defaultBand4SplitFrequencyValue_helper();
    }

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

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

      if (v != mBand5SplitFrequency && !isBand5SplitFrequencyImmutable()) {
        mBand5SplitFrequency = v;
        Q_EMIT band5SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band5SplitFrequency READ band5SplitFrequency WRITE setBand5SplitFrequency NOTIFY band5SplitFrequencyChanged)
    Q_PROPERTY(bool isBand5SplitFrequencyImmutable READ isBand5SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5SplitFrequencyValue READ defaultBand5SplitFrequencyValue CONSTANT)
    /**
      Get band5SplitFrequency
    */
    double band5SplitFrequency() const
    {
      return mBand5SplitFrequency;
    }

    /**
      Is band5SplitFrequency Immutable
    */
    bool isBand5SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SplitFrequency" ) );
    }

    /**
      Get band5SplitFrequency default value
    */
    double defaultBand5SplitFrequencyValue() const
    {
        return defaultBand5SplitFrequencyValue_helper();
    }

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

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

      if (v != mBand6SplitFrequency && !isBand6SplitFrequencyImmutable()) {
        mBand6SplitFrequency = v;
        Q_EMIT band6SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band6SplitFrequency READ band6SplitFrequency WRITE setBand6SplitFrequency NOTIFY band6SplitFrequencyChanged)
    Q_PROPERTY(bool isBand6SplitFrequencyImmutable READ isBand6SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6SplitFrequencyValue READ defaultBand6SplitFrequencyValue CONSTANT)
    /**
      Get band6SplitFrequency
    */
    double band6SplitFrequency() const
    {
      return mBand6SplitFrequency;
    }

    /**
      Is band6SplitFrequency Immutable
    */
    bool isBand6SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SplitFrequency" ) );
    }

    /**
      Get band6SplitFrequency default value
    */
    double defaultBand6SplitFrequencyValue() const
    {
        return defaultBand6SplitFrequencyValue_helper();
    }

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

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

      if (v != mBand7SplitFrequency && !isBand7SplitFrequencyImmutable()) {
        mBand7SplitFrequency = v;
        Q_EMIT band7SplitFrequencyChanged();
      }
    }

    Q_PROPERTY(double band7SplitFrequency READ band7SplitFrequency WRITE setBand7SplitFrequency NOTIFY band7SplitFrequencyChanged)
    Q_PROPERTY(bool isBand7SplitFrequencyImmutable READ isBand7SplitFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7SplitFrequencyValue READ defaultBand7SplitFrequencyValue CONSTANT)
    /**
      Get band7SplitFrequency
    */
    double band7SplitFrequency() const
    {
      return mBand7SplitFrequency;
    }

    /**
      Is band7SplitFrequency Immutable
    */
    bool isBand7SplitFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SplitFrequency" ) );
    }

    /**
      Get band7SplitFrequency default value
    */
    double defaultBand7SplitFrequencyValue() const
    {
        return defaultBand7SplitFrequencyValue_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 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 setBand0SidechainType( int v )
    {
      if (v != mBand0SidechainType && !isBand0SidechainTypeImmutable()) {
        mBand0SidechainType = v;
        Q_EMIT band0SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band0SidechainType READ band0SidechainType WRITE setBand0SidechainType NOTIFY band0SidechainTypeChanged)
    Q_PROPERTY(bool isBand0SidechainTypeImmutable READ isBand0SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand0SidechainTypeValue READ defaultBand0SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band0SidechainType() const
    {
      return mBand0SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand0SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand0SidechainTypeValue() const
    {
        return defaultBand0SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand1SidechainType( int v )
    {
      if (v != mBand1SidechainType && !isBand1SidechainTypeImmutable()) {
        mBand1SidechainType = v;
        Q_EMIT band1SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band1SidechainType READ band1SidechainType WRITE setBand1SidechainType NOTIFY band1SidechainTypeChanged)
    Q_PROPERTY(bool isBand1SidechainTypeImmutable READ isBand1SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand1SidechainTypeValue READ defaultBand1SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band1SidechainType() const
    {
      return mBand1SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand1SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand1SidechainTypeValue() const
    {
        return defaultBand1SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand2SidechainType( int v )
    {
      if (v != mBand2SidechainType && !isBand2SidechainTypeImmutable()) {
        mBand2SidechainType = v;
        Q_EMIT band2SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band2SidechainType READ band2SidechainType WRITE setBand2SidechainType NOTIFY band2SidechainTypeChanged)
    Q_PROPERTY(bool isBand2SidechainTypeImmutable READ isBand2SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand2SidechainTypeValue READ defaultBand2SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band2SidechainType() const
    {
      return mBand2SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand2SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand2SidechainTypeValue() const
    {
        return defaultBand2SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand3SidechainType( int v )
    {
      if (v != mBand3SidechainType && !isBand3SidechainTypeImmutable()) {
        mBand3SidechainType = v;
        Q_EMIT band3SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band3SidechainType READ band3SidechainType WRITE setBand3SidechainType NOTIFY band3SidechainTypeChanged)
    Q_PROPERTY(bool isBand3SidechainTypeImmutable READ isBand3SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand3SidechainTypeValue READ defaultBand3SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band3SidechainType() const
    {
      return mBand3SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand3SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand3SidechainTypeValue() const
    {
        return defaultBand3SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand4SidechainType( int v )
    {
      if (v != mBand4SidechainType && !isBand4SidechainTypeImmutable()) {
        mBand4SidechainType = v;
        Q_EMIT band4SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band4SidechainType READ band4SidechainType WRITE setBand4SidechainType NOTIFY band4SidechainTypeChanged)
    Q_PROPERTY(bool isBand4SidechainTypeImmutable READ isBand4SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand4SidechainTypeValue READ defaultBand4SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band4SidechainType() const
    {
      return mBand4SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand4SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand4SidechainTypeValue() const
    {
        return defaultBand4SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand5SidechainType( int v )
    {
      if (v != mBand5SidechainType && !isBand5SidechainTypeImmutable()) {
        mBand5SidechainType = v;
        Q_EMIT band5SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band5SidechainType READ band5SidechainType WRITE setBand5SidechainType NOTIFY band5SidechainTypeChanged)
    Q_PROPERTY(bool isBand5SidechainTypeImmutable READ isBand5SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand5SidechainTypeValue READ defaultBand5SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band5SidechainType() const
    {
      return mBand5SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand5SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand5SidechainTypeValue() const
    {
        return defaultBand5SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand6SidechainType( int v )
    {
      if (v != mBand6SidechainType && !isBand6SidechainTypeImmutable()) {
        mBand6SidechainType = v;
        Q_EMIT band6SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band6SidechainType READ band6SidechainType WRITE setBand6SidechainType NOTIFY band6SidechainTypeChanged)
    Q_PROPERTY(bool isBand6SidechainTypeImmutable READ isBand6SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand6SidechainTypeValue READ defaultBand6SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band6SidechainType() const
    {
      return mBand6SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand6SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand6SidechainTypeValue() const
    {
        return defaultBand6SidechainTypeValue_helper();
    }

    /**
      Set Sidechain Type
    */
    void setBand7SidechainType( int v )
    {
      if (v != mBand7SidechainType && !isBand7SidechainTypeImmutable()) {
        mBand7SidechainType = v;
        Q_EMIT band7SidechainTypeChanged();
      }
    }

    Q_PROPERTY(int band7SidechainType READ band7SidechainType WRITE setBand7SidechainType NOTIFY band7SidechainTypeChanged)
    Q_PROPERTY(bool isBand7SidechainTypeImmutable READ isBand7SidechainTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand7SidechainTypeValue READ defaultBand7SidechainTypeValue CONSTANT)
    /**
      Get Sidechain Type
    */
    int band7SidechainType() const
    {
      return mBand7SidechainType;
    }

    /**
      Is Sidechain Type Immutable
    */
    bool isBand7SidechainTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainType" ) );
    }

    /**
      Get Sidechain Type default value
    */
    int defaultBand7SidechainTypeValue() const
    {
        return defaultBand7SidechainTypeValue_helper();
    }

    /**
      Set sidechainModeLabels
    */
    void setSidechainModeLabels( const QStringList & v )
    {
      if (v != mSidechainModeLabels && !isSidechainModeLabelsImmutable()) {
        mSidechainModeLabels = v;
        Q_EMIT sidechainModeLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList sidechainModeLabels READ sidechainModeLabels WRITE setSidechainModeLabels NOTIFY sidechainModeLabelsChanged)
    Q_PROPERTY(bool isSidechainModeLabelsImmutable READ isSidechainModeLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultSidechainModeLabelsValue READ defaultSidechainModeLabelsValue CONSTANT)
    /**
      Get sidechainModeLabels
    */
    QStringList sidechainModeLabels() const
    {
      return mSidechainModeLabels;
    }

    /**
      Is sidechainModeLabels Immutable
    */
    bool isSidechainModeLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainModeLabels" ) );
    }

    /**
      Get sidechainModeLabels default value
    */
    QStringList defaultSidechainModeLabelsValue() const
    {
        return defaultSidechainModeLabelsValue_helper();
    }

    /**
      Set band0SidechainMode
    */
    void setBand0SidechainMode( int v )
    {
      if (v != mBand0SidechainMode && !isBand0SidechainModeImmutable()) {
        mBand0SidechainMode = v;
        Q_EMIT band0SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band0SidechainMode READ band0SidechainMode WRITE setBand0SidechainMode NOTIFY band0SidechainModeChanged)
    Q_PROPERTY(bool isBand0SidechainModeImmutable READ isBand0SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand0SidechainModeValue READ defaultBand0SidechainModeValue CONSTANT)
    /**
      Get band0SidechainMode
    */
    int band0SidechainMode() const
    {
      return mBand0SidechainMode;
    }

    /**
      Is band0SidechainMode Immutable
    */
    bool isBand0SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainMode" ) );
    }

    /**
      Get band0SidechainMode default value
    */
    int defaultBand0SidechainModeValue() const
    {
        return defaultBand0SidechainModeValue_helper();
    }

    /**
      Set band1SidechainMode
    */
    void setBand1SidechainMode( int v )
    {
      if (v != mBand1SidechainMode && !isBand1SidechainModeImmutable()) {
        mBand1SidechainMode = v;
        Q_EMIT band1SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band1SidechainMode READ band1SidechainMode WRITE setBand1SidechainMode NOTIFY band1SidechainModeChanged)
    Q_PROPERTY(bool isBand1SidechainModeImmutable READ isBand1SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand1SidechainModeValue READ defaultBand1SidechainModeValue CONSTANT)
    /**
      Get band1SidechainMode
    */
    int band1SidechainMode() const
    {
      return mBand1SidechainMode;
    }

    /**
      Is band1SidechainMode Immutable
    */
    bool isBand1SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainMode" ) );
    }

    /**
      Get band1SidechainMode default value
    */
    int defaultBand1SidechainModeValue() const
    {
        return defaultBand1SidechainModeValue_helper();
    }

    /**
      Set band2SidechainMode
    */
    void setBand2SidechainMode( int v )
    {
      if (v != mBand2SidechainMode && !isBand2SidechainModeImmutable()) {
        mBand2SidechainMode = v;
        Q_EMIT band2SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band2SidechainMode READ band2SidechainMode WRITE setBand2SidechainMode NOTIFY band2SidechainModeChanged)
    Q_PROPERTY(bool isBand2SidechainModeImmutable READ isBand2SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand2SidechainModeValue READ defaultBand2SidechainModeValue CONSTANT)
    /**
      Get band2SidechainMode
    */
    int band2SidechainMode() const
    {
      return mBand2SidechainMode;
    }

    /**
      Is band2SidechainMode Immutable
    */
    bool isBand2SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainMode" ) );
    }

    /**
      Get band2SidechainMode default value
    */
    int defaultBand2SidechainModeValue() const
    {
        return defaultBand2SidechainModeValue_helper();
    }

    /**
      Set band3SidechainMode
    */
    void setBand3SidechainMode( int v )
    {
      if (v != mBand3SidechainMode && !isBand3SidechainModeImmutable()) {
        mBand3SidechainMode = v;
        Q_EMIT band3SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band3SidechainMode READ band3SidechainMode WRITE setBand3SidechainMode NOTIFY band3SidechainModeChanged)
    Q_PROPERTY(bool isBand3SidechainModeImmutable READ isBand3SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand3SidechainModeValue READ defaultBand3SidechainModeValue CONSTANT)
    /**
      Get band3SidechainMode
    */
    int band3SidechainMode() const
    {
      return mBand3SidechainMode;
    }

    /**
      Is band3SidechainMode Immutable
    */
    bool isBand3SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainMode" ) );
    }

    /**
      Get band3SidechainMode default value
    */
    int defaultBand3SidechainModeValue() const
    {
        return defaultBand3SidechainModeValue_helper();
    }

    /**
      Set band4SidechainMode
    */
    void setBand4SidechainMode( int v )
    {
      if (v != mBand4SidechainMode && !isBand4SidechainModeImmutable()) {
        mBand4SidechainMode = v;
        Q_EMIT band4SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band4SidechainMode READ band4SidechainMode WRITE setBand4SidechainMode NOTIFY band4SidechainModeChanged)
    Q_PROPERTY(bool isBand4SidechainModeImmutable READ isBand4SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand4SidechainModeValue READ defaultBand4SidechainModeValue CONSTANT)
    /**
      Get band4SidechainMode
    */
    int band4SidechainMode() const
    {
      return mBand4SidechainMode;
    }

    /**
      Is band4SidechainMode Immutable
    */
    bool isBand4SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainMode" ) );
    }

    /**
      Get band4SidechainMode default value
    */
    int defaultBand4SidechainModeValue() const
    {
        return defaultBand4SidechainModeValue_helper();
    }

    /**
      Set band5SidechainMode
    */
    void setBand5SidechainMode( int v )
    {
      if (v != mBand5SidechainMode && !isBand5SidechainModeImmutable()) {
        mBand5SidechainMode = v;
        Q_EMIT band5SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band5SidechainMode READ band5SidechainMode WRITE setBand5SidechainMode NOTIFY band5SidechainModeChanged)
    Q_PROPERTY(bool isBand5SidechainModeImmutable READ isBand5SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand5SidechainModeValue READ defaultBand5SidechainModeValue CONSTANT)
    /**
      Get band5SidechainMode
    */
    int band5SidechainMode() const
    {
      return mBand5SidechainMode;
    }

    /**
      Is band5SidechainMode Immutable
    */
    bool isBand5SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainMode" ) );
    }

    /**
      Get band5SidechainMode default value
    */
    int defaultBand5SidechainModeValue() const
    {
        return defaultBand5SidechainModeValue_helper();
    }

    /**
      Set band6SidechainMode
    */
    void setBand6SidechainMode( int v )
    {
      if (v != mBand6SidechainMode && !isBand6SidechainModeImmutable()) {
        mBand6SidechainMode = v;
        Q_EMIT band6SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band6SidechainMode READ band6SidechainMode WRITE setBand6SidechainMode NOTIFY band6SidechainModeChanged)
    Q_PROPERTY(bool isBand6SidechainModeImmutable READ isBand6SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand6SidechainModeValue READ defaultBand6SidechainModeValue CONSTANT)
    /**
      Get band6SidechainMode
    */
    int band6SidechainMode() const
    {
      return mBand6SidechainMode;
    }

    /**
      Is band6SidechainMode Immutable
    */
    bool isBand6SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainMode" ) );
    }

    /**
      Get band6SidechainMode default value
    */
    int defaultBand6SidechainModeValue() const
    {
        return defaultBand6SidechainModeValue_helper();
    }

    /**
      Set band7SidechainMode
    */
    void setBand7SidechainMode( int v )
    {
      if (v != mBand7SidechainMode && !isBand7SidechainModeImmutable()) {
        mBand7SidechainMode = v;
        Q_EMIT band7SidechainModeChanged();
      }
    }

    Q_PROPERTY(int band7SidechainMode READ band7SidechainMode WRITE setBand7SidechainMode NOTIFY band7SidechainModeChanged)
    Q_PROPERTY(bool isBand7SidechainModeImmutable READ isBand7SidechainModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand7SidechainModeValue READ defaultBand7SidechainModeValue CONSTANT)
    /**
      Get band7SidechainMode
    */
    int band7SidechainMode() const
    {
      return mBand7SidechainMode;
    }

    /**
      Is band7SidechainMode Immutable
    */
    bool isBand7SidechainModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainMode" ) );
    }

    /**
      Get band7SidechainMode default value
    */
    int defaultBand7SidechainModeValue() const
    {
        return defaultBand7SidechainModeValue_helper();
    }

    /**
      Set sidechainSourceLabels
    */
    void setSidechainSourceLabels( const QStringList & v )
    {
      if (v != mSidechainSourceLabels && !isSidechainSourceLabelsImmutable()) {
        mSidechainSourceLabels = v;
        Q_EMIT sidechainSourceLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList sidechainSourceLabels READ sidechainSourceLabels WRITE setSidechainSourceLabels NOTIFY sidechainSourceLabelsChanged)
    Q_PROPERTY(bool isSidechainSourceLabelsImmutable READ isSidechainSourceLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultSidechainSourceLabelsValue READ defaultSidechainSourceLabelsValue CONSTANT)
    /**
      Get sidechainSourceLabels
    */
    QStringList sidechainSourceLabels() const
    {
      return mSidechainSourceLabels;
    }

    /**
      Is sidechainSourceLabels Immutable
    */
    bool isSidechainSourceLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "sidechainSourceLabels" ) );
    }

    /**
      Get sidechainSourceLabels default value
    */
    QStringList defaultSidechainSourceLabelsValue() const
    {
        return defaultSidechainSourceLabelsValue_helper();
    }

    /**
      Set band0SidechainSource
    */
    void setBand0SidechainSource( int v )
    {
      if (v != mBand0SidechainSource && !isBand0SidechainSourceImmutable()) {
        mBand0SidechainSource = v;
        Q_EMIT band0SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band0SidechainSource READ band0SidechainSource WRITE setBand0SidechainSource NOTIFY band0SidechainSourceChanged)
    Q_PROPERTY(bool isBand0SidechainSourceImmutable READ isBand0SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand0SidechainSourceValue READ defaultBand0SidechainSourceValue CONSTANT)
    /**
      Get band0SidechainSource
    */
    int band0SidechainSource() const
    {
      return mBand0SidechainSource;
    }

    /**
      Is band0SidechainSource Immutable
    */
    bool isBand0SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainSource" ) );
    }

    /**
      Get band0SidechainSource default value
    */
    int defaultBand0SidechainSourceValue() const
    {
        return defaultBand0SidechainSourceValue_helper();
    }

    /**
      Set band1SidechainSource
    */
    void setBand1SidechainSource( int v )
    {
      if (v != mBand1SidechainSource && !isBand1SidechainSourceImmutable()) {
        mBand1SidechainSource = v;
        Q_EMIT band1SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band1SidechainSource READ band1SidechainSource WRITE setBand1SidechainSource NOTIFY band1SidechainSourceChanged)
    Q_PROPERTY(bool isBand1SidechainSourceImmutable READ isBand1SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand1SidechainSourceValue READ defaultBand1SidechainSourceValue CONSTANT)
    /**
      Get band1SidechainSource
    */
    int band1SidechainSource() const
    {
      return mBand1SidechainSource;
    }

    /**
      Is band1SidechainSource Immutable
    */
    bool isBand1SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainSource" ) );
    }

    /**
      Get band1SidechainSource default value
    */
    int defaultBand1SidechainSourceValue() const
    {
        return defaultBand1SidechainSourceValue_helper();
    }

    /**
      Set band2SidechainSource
    */
    void setBand2SidechainSource( int v )
    {
      if (v != mBand2SidechainSource && !isBand2SidechainSourceImmutable()) {
        mBand2SidechainSource = v;
        Q_EMIT band2SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band2SidechainSource READ band2SidechainSource WRITE setBand2SidechainSource NOTIFY band2SidechainSourceChanged)
    Q_PROPERTY(bool isBand2SidechainSourceImmutable READ isBand2SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand2SidechainSourceValue READ defaultBand2SidechainSourceValue CONSTANT)
    /**
      Get band2SidechainSource
    */
    int band2SidechainSource() const
    {
      return mBand2SidechainSource;
    }

    /**
      Is band2SidechainSource Immutable
    */
    bool isBand2SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainSource" ) );
    }

    /**
      Get band2SidechainSource default value
    */
    int defaultBand2SidechainSourceValue() const
    {
        return defaultBand2SidechainSourceValue_helper();
    }

    /**
      Set band3SidechainSource
    */
    void setBand3SidechainSource( int v )
    {
      if (v != mBand3SidechainSource && !isBand3SidechainSourceImmutable()) {
        mBand3SidechainSource = v;
        Q_EMIT band3SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band3SidechainSource READ band3SidechainSource WRITE setBand3SidechainSource NOTIFY band3SidechainSourceChanged)
    Q_PROPERTY(bool isBand3SidechainSourceImmutable READ isBand3SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand3SidechainSourceValue READ defaultBand3SidechainSourceValue CONSTANT)
    /**
      Get band3SidechainSource
    */
    int band3SidechainSource() const
    {
      return mBand3SidechainSource;
    }

    /**
      Is band3SidechainSource Immutable
    */
    bool isBand3SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainSource" ) );
    }

    /**
      Get band3SidechainSource default value
    */
    int defaultBand3SidechainSourceValue() const
    {
        return defaultBand3SidechainSourceValue_helper();
    }

    /**
      Set band4SidechainSource
    */
    void setBand4SidechainSource( int v )
    {
      if (v != mBand4SidechainSource && !isBand4SidechainSourceImmutable()) {
        mBand4SidechainSource = v;
        Q_EMIT band4SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band4SidechainSource READ band4SidechainSource WRITE setBand4SidechainSource NOTIFY band4SidechainSourceChanged)
    Q_PROPERTY(bool isBand4SidechainSourceImmutable READ isBand4SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand4SidechainSourceValue READ defaultBand4SidechainSourceValue CONSTANT)
    /**
      Get band4SidechainSource
    */
    int band4SidechainSource() const
    {
      return mBand4SidechainSource;
    }

    /**
      Is band4SidechainSource Immutable
    */
    bool isBand4SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainSource" ) );
    }

    /**
      Get band4SidechainSource default value
    */
    int defaultBand4SidechainSourceValue() const
    {
        return defaultBand4SidechainSourceValue_helper();
    }

    /**
      Set band5SidechainSource
    */
    void setBand5SidechainSource( int v )
    {
      if (v != mBand5SidechainSource && !isBand5SidechainSourceImmutable()) {
        mBand5SidechainSource = v;
        Q_EMIT band5SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band5SidechainSource READ band5SidechainSource WRITE setBand5SidechainSource NOTIFY band5SidechainSourceChanged)
    Q_PROPERTY(bool isBand5SidechainSourceImmutable READ isBand5SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand5SidechainSourceValue READ defaultBand5SidechainSourceValue CONSTANT)
    /**
      Get band5SidechainSource
    */
    int band5SidechainSource() const
    {
      return mBand5SidechainSource;
    }

    /**
      Is band5SidechainSource Immutable
    */
    bool isBand5SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainSource" ) );
    }

    /**
      Get band5SidechainSource default value
    */
    int defaultBand5SidechainSourceValue() const
    {
        return defaultBand5SidechainSourceValue_helper();
    }

    /**
      Set band6SidechainSource
    */
    void setBand6SidechainSource( int v )
    {
      if (v != mBand6SidechainSource && !isBand6SidechainSourceImmutable()) {
        mBand6SidechainSource = v;
        Q_EMIT band6SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band6SidechainSource READ band6SidechainSource WRITE setBand6SidechainSource NOTIFY band6SidechainSourceChanged)
    Q_PROPERTY(bool isBand6SidechainSourceImmutable READ isBand6SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand6SidechainSourceValue READ defaultBand6SidechainSourceValue CONSTANT)
    /**
      Get band6SidechainSource
    */
    int band6SidechainSource() const
    {
      return mBand6SidechainSource;
    }

    /**
      Is band6SidechainSource Immutable
    */
    bool isBand6SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainSource" ) );
    }

    /**
      Get band6SidechainSource default value
    */
    int defaultBand6SidechainSourceValue() const
    {
        return defaultBand6SidechainSourceValue_helper();
    }

    /**
      Set band7SidechainSource
    */
    void setBand7SidechainSource( int v )
    {
      if (v != mBand7SidechainSource && !isBand7SidechainSourceImmutable()) {
        mBand7SidechainSource = v;
        Q_EMIT band7SidechainSourceChanged();
      }
    }

    Q_PROPERTY(int band7SidechainSource READ band7SidechainSource WRITE setBand7SidechainSource NOTIFY band7SidechainSourceChanged)
    Q_PROPERTY(bool isBand7SidechainSourceImmutable READ isBand7SidechainSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand7SidechainSourceValue READ defaultBand7SidechainSourceValue CONSTANT)
    /**
      Get band7SidechainSource
    */
    int band7SidechainSource() const
    {
      return mBand7SidechainSource;
    }

    /**
      Is band7SidechainSource Immutable
    */
    bool isBand7SidechainSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainSource" ) );
    }

    /**
      Get band7SidechainSource default value
    */
    int defaultBand7SidechainSourceValue() const
    {
        return defaultBand7SidechainSourceValue_helper();
    }

    /**
      Set stereoSplitSourceLabels
    */
    void setStereoSplitSourceLabels( const QStringList & v )
    {
      if (v != mStereoSplitSourceLabels && !isStereoSplitSourceLabelsImmutable()) {
        mStereoSplitSourceLabels = v;
        Q_EMIT stereoSplitSourceLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList stereoSplitSourceLabels READ stereoSplitSourceLabels WRITE setStereoSplitSourceLabels NOTIFY stereoSplitSourceLabelsChanged)
    Q_PROPERTY(bool isStereoSplitSourceLabelsImmutable READ isStereoSplitSourceLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultStereoSplitSourceLabelsValue READ defaultStereoSplitSourceLabelsValue CONSTANT)
    /**
      Get stereoSplitSourceLabels
    */
    QStringList stereoSplitSourceLabels() const
    {
      return mStereoSplitSourceLabels;
    }

    /**
      Is stereoSplitSourceLabels Immutable
    */
    bool isStereoSplitSourceLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "stereoSplitSourceLabels" ) );
    }

    /**
      Get stereoSplitSourceLabels default value
    */
    QStringList defaultStereoSplitSourceLabelsValue() const
    {
        return defaultStereoSplitSourceLabelsValue_helper();
    }

    /**
      Set band0StereoSplitSource
    */
    void setBand0StereoSplitSource( int v )
    {
      if (v != mBand0StereoSplitSource && !isBand0StereoSplitSourceImmutable()) {
        mBand0StereoSplitSource = v;
        Q_EMIT band0StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band0StereoSplitSource READ band0StereoSplitSource WRITE setBand0StereoSplitSource NOTIFY band0StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand0StereoSplitSourceImmutable READ isBand0StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand0StereoSplitSourceValue READ defaultBand0StereoSplitSourceValue CONSTANT)
    /**
      Get band0StereoSplitSource
    */
    int band0StereoSplitSource() const
    {
      return mBand0StereoSplitSource;
    }

    /**
      Is band0StereoSplitSource Immutable
    */
    bool isBand0StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band0StereoSplitSource" ) );
    }

    /**
      Get band0StereoSplitSource default value
    */
    int defaultBand0StereoSplitSourceValue() const
    {
        return defaultBand0StereoSplitSourceValue_helper();
    }

    /**
      Set band1StereoSplitSource
    */
    void setBand1StereoSplitSource( int v )
    {
      if (v != mBand1StereoSplitSource && !isBand1StereoSplitSourceImmutable()) {
        mBand1StereoSplitSource = v;
        Q_EMIT band1StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band1StereoSplitSource READ band1StereoSplitSource WRITE setBand1StereoSplitSource NOTIFY band1StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand1StereoSplitSourceImmutable READ isBand1StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand1StereoSplitSourceValue READ defaultBand1StereoSplitSourceValue CONSTANT)
    /**
      Get band1StereoSplitSource
    */
    int band1StereoSplitSource() const
    {
      return mBand1StereoSplitSource;
    }

    /**
      Is band1StereoSplitSource Immutable
    */
    bool isBand1StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band1StereoSplitSource" ) );
    }

    /**
      Get band1StereoSplitSource default value
    */
    int defaultBand1StereoSplitSourceValue() const
    {
        return defaultBand1StereoSplitSourceValue_helper();
    }

    /**
      Set band2StereoSplitSource
    */
    void setBand2StereoSplitSource( int v )
    {
      if (v != mBand2StereoSplitSource && !isBand2StereoSplitSourceImmutable()) {
        mBand2StereoSplitSource = v;
        Q_EMIT band2StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band2StereoSplitSource READ band2StereoSplitSource WRITE setBand2StereoSplitSource NOTIFY band2StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand2StereoSplitSourceImmutable READ isBand2StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand2StereoSplitSourceValue READ defaultBand2StereoSplitSourceValue CONSTANT)
    /**
      Get band2StereoSplitSource
    */
    int band2StereoSplitSource() const
    {
      return mBand2StereoSplitSource;
    }

    /**
      Is band2StereoSplitSource Immutable
    */
    bool isBand2StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band2StereoSplitSource" ) );
    }

    /**
      Get band2StereoSplitSource default value
    */
    int defaultBand2StereoSplitSourceValue() const
    {
        return defaultBand2StereoSplitSourceValue_helper();
    }

    /**
      Set band3StereoSplitSource
    */
    void setBand3StereoSplitSource( int v )
    {
      if (v != mBand3StereoSplitSource && !isBand3StereoSplitSourceImmutable()) {
        mBand3StereoSplitSource = v;
        Q_EMIT band3StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band3StereoSplitSource READ band3StereoSplitSource WRITE setBand3StereoSplitSource NOTIFY band3StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand3StereoSplitSourceImmutable READ isBand3StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand3StereoSplitSourceValue READ defaultBand3StereoSplitSourceValue CONSTANT)
    /**
      Get band3StereoSplitSource
    */
    int band3StereoSplitSource() const
    {
      return mBand3StereoSplitSource;
    }

    /**
      Is band3StereoSplitSource Immutable
    */
    bool isBand3StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band3StereoSplitSource" ) );
    }

    /**
      Get band3StereoSplitSource default value
    */
    int defaultBand3StereoSplitSourceValue() const
    {
        return defaultBand3StereoSplitSourceValue_helper();
    }

    /**
      Set band4StereoSplitSource
    */
    void setBand4StereoSplitSource( int v )
    {
      if (v != mBand4StereoSplitSource && !isBand4StereoSplitSourceImmutable()) {
        mBand4StereoSplitSource = v;
        Q_EMIT band4StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band4StereoSplitSource READ band4StereoSplitSource WRITE setBand4StereoSplitSource NOTIFY band4StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand4StereoSplitSourceImmutable READ isBand4StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand4StereoSplitSourceValue READ defaultBand4StereoSplitSourceValue CONSTANT)
    /**
      Get band4StereoSplitSource
    */
    int band4StereoSplitSource() const
    {
      return mBand4StereoSplitSource;
    }

    /**
      Is band4StereoSplitSource Immutable
    */
    bool isBand4StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band4StereoSplitSource" ) );
    }

    /**
      Get band4StereoSplitSource default value
    */
    int defaultBand4StereoSplitSourceValue() const
    {
        return defaultBand4StereoSplitSourceValue_helper();
    }

    /**
      Set band5StereoSplitSource
    */
    void setBand5StereoSplitSource( int v )
    {
      if (v != mBand5StereoSplitSource && !isBand5StereoSplitSourceImmutable()) {
        mBand5StereoSplitSource = v;
        Q_EMIT band5StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band5StereoSplitSource READ band5StereoSplitSource WRITE setBand5StereoSplitSource NOTIFY band5StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand5StereoSplitSourceImmutable READ isBand5StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand5StereoSplitSourceValue READ defaultBand5StereoSplitSourceValue CONSTANT)
    /**
      Get band5StereoSplitSource
    */
    int band5StereoSplitSource() const
    {
      return mBand5StereoSplitSource;
    }

    /**
      Is band5StereoSplitSource Immutable
    */
    bool isBand5StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band5StereoSplitSource" ) );
    }

    /**
      Get band5StereoSplitSource default value
    */
    int defaultBand5StereoSplitSourceValue() const
    {
        return defaultBand5StereoSplitSourceValue_helper();
    }

    /**
      Set band6StereoSplitSource
    */
    void setBand6StereoSplitSource( int v )
    {
      if (v != mBand6StereoSplitSource && !isBand6StereoSplitSourceImmutable()) {
        mBand6StereoSplitSource = v;
        Q_EMIT band6StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band6StereoSplitSource READ band6StereoSplitSource WRITE setBand6StereoSplitSource NOTIFY band6StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand6StereoSplitSourceImmutable READ isBand6StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand6StereoSplitSourceValue READ defaultBand6StereoSplitSourceValue CONSTANT)
    /**
      Get band6StereoSplitSource
    */
    int band6StereoSplitSource() const
    {
      return mBand6StereoSplitSource;
    }

    /**
      Is band6StereoSplitSource Immutable
    */
    bool isBand6StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band6StereoSplitSource" ) );
    }

    /**
      Get band6StereoSplitSource default value
    */
    int defaultBand6StereoSplitSourceValue() const
    {
        return defaultBand6StereoSplitSourceValue_helper();
    }

    /**
      Set band7StereoSplitSource
    */
    void setBand7StereoSplitSource( int v )
    {
      if (v != mBand7StereoSplitSource && !isBand7StereoSplitSourceImmutable()) {
        mBand7StereoSplitSource = v;
        Q_EMIT band7StereoSplitSourceChanged();
      }
    }

    Q_PROPERTY(int band7StereoSplitSource READ band7StereoSplitSource WRITE setBand7StereoSplitSource NOTIFY band7StereoSplitSourceChanged)
    Q_PROPERTY(bool isBand7StereoSplitSourceImmutable READ isBand7StereoSplitSourceImmutable CONSTANT)
    Q_PROPERTY(int defaultBand7StereoSplitSourceValue READ defaultBand7StereoSplitSourceValue CONSTANT)
    /**
      Get band7StereoSplitSource
    */
    int band7StereoSplitSource() const
    {
      return mBand7StereoSplitSource;
    }

    /**
      Is band7StereoSplitSource Immutable
    */
    bool isBand7StereoSplitSourceImmutable() const
    {
      return isImmutable( QStringLiteral( "band7StereoSplitSource" ) );
    }

    /**
      Get band7StereoSplitSource default value
    */
    int defaultBand7StereoSplitSourceValue() const
    {
        return defaultBand7StereoSplitSourceValue_helper();
    }

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

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

      if (v != mBand0SidechainLookahead && !isBand0SidechainLookaheadImmutable()) {
        mBand0SidechainLookahead = v;
        Q_EMIT band0SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band0SidechainLookahead READ band0SidechainLookahead WRITE setBand0SidechainLookahead NOTIFY band0SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand0SidechainLookaheadImmutable READ isBand0SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0SidechainLookaheadValue READ defaultBand0SidechainLookaheadValue CONSTANT)
    /**
      Get band0SidechainLookahead
    */
    double band0SidechainLookahead() const
    {
      return mBand0SidechainLookahead;
    }

    /**
      Is band0SidechainLookahead Immutable
    */
    bool isBand0SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainLookahead" ) );
    }

    /**
      Get band0SidechainLookahead default value
    */
    double defaultBand0SidechainLookaheadValue() const
    {
        return defaultBand0SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand1SidechainLookahead && !isBand1SidechainLookaheadImmutable()) {
        mBand1SidechainLookahead = v;
        Q_EMIT band1SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band1SidechainLookahead READ band1SidechainLookahead WRITE setBand1SidechainLookahead NOTIFY band1SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand1SidechainLookaheadImmutable READ isBand1SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1SidechainLookaheadValue READ defaultBand1SidechainLookaheadValue CONSTANT)
    /**
      Get band1SidechainLookahead
    */
    double band1SidechainLookahead() const
    {
      return mBand1SidechainLookahead;
    }

    /**
      Is band1SidechainLookahead Immutable
    */
    bool isBand1SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainLookahead" ) );
    }

    /**
      Get band1SidechainLookahead default value
    */
    double defaultBand1SidechainLookaheadValue() const
    {
        return defaultBand1SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand2SidechainLookahead && !isBand2SidechainLookaheadImmutable()) {
        mBand2SidechainLookahead = v;
        Q_EMIT band2SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band2SidechainLookahead READ band2SidechainLookahead WRITE setBand2SidechainLookahead NOTIFY band2SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand2SidechainLookaheadImmutable READ isBand2SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2SidechainLookaheadValue READ defaultBand2SidechainLookaheadValue CONSTANT)
    /**
      Get band2SidechainLookahead
    */
    double band2SidechainLookahead() const
    {
      return mBand2SidechainLookahead;
    }

    /**
      Is band2SidechainLookahead Immutable
    */
    bool isBand2SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainLookahead" ) );
    }

    /**
      Get band2SidechainLookahead default value
    */
    double defaultBand2SidechainLookaheadValue() const
    {
        return defaultBand2SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand3SidechainLookahead && !isBand3SidechainLookaheadImmutable()) {
        mBand3SidechainLookahead = v;
        Q_EMIT band3SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band3SidechainLookahead READ band3SidechainLookahead WRITE setBand3SidechainLookahead NOTIFY band3SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand3SidechainLookaheadImmutable READ isBand3SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3SidechainLookaheadValue READ defaultBand3SidechainLookaheadValue CONSTANT)
    /**
      Get band3SidechainLookahead
    */
    double band3SidechainLookahead() const
    {
      return mBand3SidechainLookahead;
    }

    /**
      Is band3SidechainLookahead Immutable
    */
    bool isBand3SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainLookahead" ) );
    }

    /**
      Get band3SidechainLookahead default value
    */
    double defaultBand3SidechainLookaheadValue() const
    {
        return defaultBand3SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand4SidechainLookahead && !isBand4SidechainLookaheadImmutable()) {
        mBand4SidechainLookahead = v;
        Q_EMIT band4SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band4SidechainLookahead READ band4SidechainLookahead WRITE setBand4SidechainLookahead NOTIFY band4SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand4SidechainLookaheadImmutable READ isBand4SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4SidechainLookaheadValue READ defaultBand4SidechainLookaheadValue CONSTANT)
    /**
      Get band4SidechainLookahead
    */
    double band4SidechainLookahead() const
    {
      return mBand4SidechainLookahead;
    }

    /**
      Is band4SidechainLookahead Immutable
    */
    bool isBand4SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainLookahead" ) );
    }

    /**
      Get band4SidechainLookahead default value
    */
    double defaultBand4SidechainLookaheadValue() const
    {
        return defaultBand4SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand5SidechainLookahead && !isBand5SidechainLookaheadImmutable()) {
        mBand5SidechainLookahead = v;
        Q_EMIT band5SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band5SidechainLookahead READ band5SidechainLookahead WRITE setBand5SidechainLookahead NOTIFY band5SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand5SidechainLookaheadImmutable READ isBand5SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5SidechainLookaheadValue READ defaultBand5SidechainLookaheadValue CONSTANT)
    /**
      Get band5SidechainLookahead
    */
    double band5SidechainLookahead() const
    {
      return mBand5SidechainLookahead;
    }

    /**
      Is band5SidechainLookahead Immutable
    */
    bool isBand5SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainLookahead" ) );
    }

    /**
      Get band5SidechainLookahead default value
    */
    double defaultBand5SidechainLookaheadValue() const
    {
        return defaultBand5SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand6SidechainLookahead && !isBand6SidechainLookaheadImmutable()) {
        mBand6SidechainLookahead = v;
        Q_EMIT band6SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band6SidechainLookahead READ band6SidechainLookahead WRITE setBand6SidechainLookahead NOTIFY band6SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand6SidechainLookaheadImmutable READ isBand6SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6SidechainLookaheadValue READ defaultBand6SidechainLookaheadValue CONSTANT)
    /**
      Get band6SidechainLookahead
    */
    double band6SidechainLookahead() const
    {
      return mBand6SidechainLookahead;
    }

    /**
      Is band6SidechainLookahead Immutable
    */
    bool isBand6SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainLookahead" ) );
    }

    /**
      Get band6SidechainLookahead default value
    */
    double defaultBand6SidechainLookaheadValue() const
    {
        return defaultBand6SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand7SidechainLookahead && !isBand7SidechainLookaheadImmutable()) {
        mBand7SidechainLookahead = v;
        Q_EMIT band7SidechainLookaheadChanged();
      }
    }

    Q_PROPERTY(double band7SidechainLookahead READ band7SidechainLookahead WRITE setBand7SidechainLookahead NOTIFY band7SidechainLookaheadChanged)
    Q_PROPERTY(bool isBand7SidechainLookaheadImmutable READ isBand7SidechainLookaheadImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7SidechainLookaheadValue READ defaultBand7SidechainLookaheadValue CONSTANT)
    /**
      Get band7SidechainLookahead
    */
    double band7SidechainLookahead() const
    {
      return mBand7SidechainLookahead;
    }

    /**
      Is band7SidechainLookahead Immutable
    */
    bool isBand7SidechainLookaheadImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainLookahead" ) );
    }

    /**
      Get band7SidechainLookahead default value
    */
    double defaultBand7SidechainLookaheadValue() const
    {
        return defaultBand7SidechainLookaheadValue_helper();
    }

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

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

      if (v != mBand0SidechainReactivity && !isBand0SidechainReactivityImmutable()) {
        mBand0SidechainReactivity = v;
        Q_EMIT band0SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band0SidechainReactivity READ band0SidechainReactivity WRITE setBand0SidechainReactivity NOTIFY band0SidechainReactivityChanged)
    Q_PROPERTY(bool isBand0SidechainReactivityImmutable READ isBand0SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0SidechainReactivityValue READ defaultBand0SidechainReactivityValue CONSTANT)
    /**
      Get band0SidechainReactivity
    */
    double band0SidechainReactivity() const
    {
      return mBand0SidechainReactivity;
    }

    /**
      Is band0SidechainReactivity Immutable
    */
    bool isBand0SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainReactivity" ) );
    }

    /**
      Get band0SidechainReactivity default value
    */
    double defaultBand0SidechainReactivityValue() const
    {
        return defaultBand0SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand1SidechainReactivity && !isBand1SidechainReactivityImmutable()) {
        mBand1SidechainReactivity = v;
        Q_EMIT band1SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band1SidechainReactivity READ band1SidechainReactivity WRITE setBand1SidechainReactivity NOTIFY band1SidechainReactivityChanged)
    Q_PROPERTY(bool isBand1SidechainReactivityImmutable READ isBand1SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1SidechainReactivityValue READ defaultBand1SidechainReactivityValue CONSTANT)
    /**
      Get band1SidechainReactivity
    */
    double band1SidechainReactivity() const
    {
      return mBand1SidechainReactivity;
    }

    /**
      Is band1SidechainReactivity Immutable
    */
    bool isBand1SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainReactivity" ) );
    }

    /**
      Get band1SidechainReactivity default value
    */
    double defaultBand1SidechainReactivityValue() const
    {
        return defaultBand1SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand2SidechainReactivity && !isBand2SidechainReactivityImmutable()) {
        mBand2SidechainReactivity = v;
        Q_EMIT band2SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band2SidechainReactivity READ band2SidechainReactivity WRITE setBand2SidechainReactivity NOTIFY band2SidechainReactivityChanged)
    Q_PROPERTY(bool isBand2SidechainReactivityImmutable READ isBand2SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2SidechainReactivityValue READ defaultBand2SidechainReactivityValue CONSTANT)
    /**
      Get band2SidechainReactivity
    */
    double band2SidechainReactivity() const
    {
      return mBand2SidechainReactivity;
    }

    /**
      Is band2SidechainReactivity Immutable
    */
    bool isBand2SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainReactivity" ) );
    }

    /**
      Get band2SidechainReactivity default value
    */
    double defaultBand2SidechainReactivityValue() const
    {
        return defaultBand2SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand3SidechainReactivity && !isBand3SidechainReactivityImmutable()) {
        mBand3SidechainReactivity = v;
        Q_EMIT band3SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band3SidechainReactivity READ band3SidechainReactivity WRITE setBand3SidechainReactivity NOTIFY band3SidechainReactivityChanged)
    Q_PROPERTY(bool isBand3SidechainReactivityImmutable READ isBand3SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3SidechainReactivityValue READ defaultBand3SidechainReactivityValue CONSTANT)
    /**
      Get band3SidechainReactivity
    */
    double band3SidechainReactivity() const
    {
      return mBand3SidechainReactivity;
    }

    /**
      Is band3SidechainReactivity Immutable
    */
    bool isBand3SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainReactivity" ) );
    }

    /**
      Get band3SidechainReactivity default value
    */
    double defaultBand3SidechainReactivityValue() const
    {
        return defaultBand3SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand4SidechainReactivity && !isBand4SidechainReactivityImmutable()) {
        mBand4SidechainReactivity = v;
        Q_EMIT band4SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band4SidechainReactivity READ band4SidechainReactivity WRITE setBand4SidechainReactivity NOTIFY band4SidechainReactivityChanged)
    Q_PROPERTY(bool isBand4SidechainReactivityImmutable READ isBand4SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4SidechainReactivityValue READ defaultBand4SidechainReactivityValue CONSTANT)
    /**
      Get band4SidechainReactivity
    */
    double band4SidechainReactivity() const
    {
      return mBand4SidechainReactivity;
    }

    /**
      Is band4SidechainReactivity Immutable
    */
    bool isBand4SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainReactivity" ) );
    }

    /**
      Get band4SidechainReactivity default value
    */
    double defaultBand4SidechainReactivityValue() const
    {
        return defaultBand4SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand5SidechainReactivity && !isBand5SidechainReactivityImmutable()) {
        mBand5SidechainReactivity = v;
        Q_EMIT band5SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band5SidechainReactivity READ band5SidechainReactivity WRITE setBand5SidechainReactivity NOTIFY band5SidechainReactivityChanged)
    Q_PROPERTY(bool isBand5SidechainReactivityImmutable READ isBand5SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5SidechainReactivityValue READ defaultBand5SidechainReactivityValue CONSTANT)
    /**
      Get band5SidechainReactivity
    */
    double band5SidechainReactivity() const
    {
      return mBand5SidechainReactivity;
    }

    /**
      Is band5SidechainReactivity Immutable
    */
    bool isBand5SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainReactivity" ) );
    }

    /**
      Get band5SidechainReactivity default value
    */
    double defaultBand5SidechainReactivityValue() const
    {
        return defaultBand5SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand6SidechainReactivity && !isBand6SidechainReactivityImmutable()) {
        mBand6SidechainReactivity = v;
        Q_EMIT band6SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band6SidechainReactivity READ band6SidechainReactivity WRITE setBand6SidechainReactivity NOTIFY band6SidechainReactivityChanged)
    Q_PROPERTY(bool isBand6SidechainReactivityImmutable READ isBand6SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6SidechainReactivityValue READ defaultBand6SidechainReactivityValue CONSTANT)
    /**
      Get band6SidechainReactivity
    */
    double band6SidechainReactivity() const
    {
      return mBand6SidechainReactivity;
    }

    /**
      Is band6SidechainReactivity Immutable
    */
    bool isBand6SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainReactivity" ) );
    }

    /**
      Get band6SidechainReactivity default value
    */
    double defaultBand6SidechainReactivityValue() const
    {
        return defaultBand6SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand7SidechainReactivity && !isBand7SidechainReactivityImmutable()) {
        mBand7SidechainReactivity = v;
        Q_EMIT band7SidechainReactivityChanged();
      }
    }

    Q_PROPERTY(double band7SidechainReactivity READ band7SidechainReactivity WRITE setBand7SidechainReactivity NOTIFY band7SidechainReactivityChanged)
    Q_PROPERTY(bool isBand7SidechainReactivityImmutable READ isBand7SidechainReactivityImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7SidechainReactivityValue READ defaultBand7SidechainReactivityValue CONSTANT)
    /**
      Get band7SidechainReactivity
    */
    double band7SidechainReactivity() const
    {
      return mBand7SidechainReactivity;
    }

    /**
      Is band7SidechainReactivity Immutable
    */
    bool isBand7SidechainReactivityImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainReactivity" ) );
    }

    /**
      Get band7SidechainReactivity default value
    */
    double defaultBand7SidechainReactivityValue() const
    {
        return defaultBand7SidechainReactivityValue_helper();
    }

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

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

      if (v != mBand0SidechainPreamp && !isBand0SidechainPreampImmutable()) {
        mBand0SidechainPreamp = v;
        Q_EMIT band0SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band0SidechainPreamp READ band0SidechainPreamp WRITE setBand0SidechainPreamp NOTIFY band0SidechainPreampChanged)
    Q_PROPERTY(bool isBand0SidechainPreampImmutable READ isBand0SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0SidechainPreampValue READ defaultBand0SidechainPreampValue CONSTANT)
    /**
      Get band0SidechainPreamp
    */
    double band0SidechainPreamp() const
    {
      return mBand0SidechainPreamp;
    }

    /**
      Is band0SidechainPreamp Immutable
    */
    bool isBand0SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainPreamp" ) );
    }

    /**
      Get band0SidechainPreamp default value
    */
    double defaultBand0SidechainPreampValue() const
    {
        return defaultBand0SidechainPreampValue_helper();
    }

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

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

      if (v != mBand1SidechainPreamp && !isBand1SidechainPreampImmutable()) {
        mBand1SidechainPreamp = v;
        Q_EMIT band1SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band1SidechainPreamp READ band1SidechainPreamp WRITE setBand1SidechainPreamp NOTIFY band1SidechainPreampChanged)
    Q_PROPERTY(bool isBand1SidechainPreampImmutable READ isBand1SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1SidechainPreampValue READ defaultBand1SidechainPreampValue CONSTANT)
    /**
      Get band1SidechainPreamp
    */
    double band1SidechainPreamp() const
    {
      return mBand1SidechainPreamp;
    }

    /**
      Is band1SidechainPreamp Immutable
    */
    bool isBand1SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainPreamp" ) );
    }

    /**
      Get band1SidechainPreamp default value
    */
    double defaultBand1SidechainPreampValue() const
    {
        return defaultBand1SidechainPreampValue_helper();
    }

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

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

      if (v != mBand2SidechainPreamp && !isBand2SidechainPreampImmutable()) {
        mBand2SidechainPreamp = v;
        Q_EMIT band2SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band2SidechainPreamp READ band2SidechainPreamp WRITE setBand2SidechainPreamp NOTIFY band2SidechainPreampChanged)
    Q_PROPERTY(bool isBand2SidechainPreampImmutable READ isBand2SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2SidechainPreampValue READ defaultBand2SidechainPreampValue CONSTANT)
    /**
      Get band2SidechainPreamp
    */
    double band2SidechainPreamp() const
    {
      return mBand2SidechainPreamp;
    }

    /**
      Is band2SidechainPreamp Immutable
    */
    bool isBand2SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainPreamp" ) );
    }

    /**
      Get band2SidechainPreamp default value
    */
    double defaultBand2SidechainPreampValue() const
    {
        return defaultBand2SidechainPreampValue_helper();
    }

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

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

      if (v != mBand3SidechainPreamp && !isBand3SidechainPreampImmutable()) {
        mBand3SidechainPreamp = v;
        Q_EMIT band3SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band3SidechainPreamp READ band3SidechainPreamp WRITE setBand3SidechainPreamp NOTIFY band3SidechainPreampChanged)
    Q_PROPERTY(bool isBand3SidechainPreampImmutable READ isBand3SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3SidechainPreampValue READ defaultBand3SidechainPreampValue CONSTANT)
    /**
      Get band3SidechainPreamp
    */
    double band3SidechainPreamp() const
    {
      return mBand3SidechainPreamp;
    }

    /**
      Is band3SidechainPreamp Immutable
    */
    bool isBand3SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainPreamp" ) );
    }

    /**
      Get band3SidechainPreamp default value
    */
    double defaultBand3SidechainPreampValue() const
    {
        return defaultBand3SidechainPreampValue_helper();
    }

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

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

      if (v != mBand4SidechainPreamp && !isBand4SidechainPreampImmutable()) {
        mBand4SidechainPreamp = v;
        Q_EMIT band4SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band4SidechainPreamp READ band4SidechainPreamp WRITE setBand4SidechainPreamp NOTIFY band4SidechainPreampChanged)
    Q_PROPERTY(bool isBand4SidechainPreampImmutable READ isBand4SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4SidechainPreampValue READ defaultBand4SidechainPreampValue CONSTANT)
    /**
      Get band4SidechainPreamp
    */
    double band4SidechainPreamp() const
    {
      return mBand4SidechainPreamp;
    }

    /**
      Is band4SidechainPreamp Immutable
    */
    bool isBand4SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainPreamp" ) );
    }

    /**
      Get band4SidechainPreamp default value
    */
    double defaultBand4SidechainPreampValue() const
    {
        return defaultBand4SidechainPreampValue_helper();
    }

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

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

      if (v != mBand5SidechainPreamp && !isBand5SidechainPreampImmutable()) {
        mBand5SidechainPreamp = v;
        Q_EMIT band5SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band5SidechainPreamp READ band5SidechainPreamp WRITE setBand5SidechainPreamp NOTIFY band5SidechainPreampChanged)
    Q_PROPERTY(bool isBand5SidechainPreampImmutable READ isBand5SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5SidechainPreampValue READ defaultBand5SidechainPreampValue CONSTANT)
    /**
      Get band5SidechainPreamp
    */
    double band5SidechainPreamp() const
    {
      return mBand5SidechainPreamp;
    }

    /**
      Is band5SidechainPreamp Immutable
    */
    bool isBand5SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainPreamp" ) );
    }

    /**
      Get band5SidechainPreamp default value
    */
    double defaultBand5SidechainPreampValue() const
    {
        return defaultBand5SidechainPreampValue_helper();
    }

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

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

      if (v != mBand6SidechainPreamp && !isBand6SidechainPreampImmutable()) {
        mBand6SidechainPreamp = v;
        Q_EMIT band6SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band6SidechainPreamp READ band6SidechainPreamp WRITE setBand6SidechainPreamp NOTIFY band6SidechainPreampChanged)
    Q_PROPERTY(bool isBand6SidechainPreampImmutable READ isBand6SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6SidechainPreampValue READ defaultBand6SidechainPreampValue CONSTANT)
    /**
      Get band6SidechainPreamp
    */
    double band6SidechainPreamp() const
    {
      return mBand6SidechainPreamp;
    }

    /**
      Is band6SidechainPreamp Immutable
    */
    bool isBand6SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainPreamp" ) );
    }

    /**
      Get band6SidechainPreamp default value
    */
    double defaultBand6SidechainPreampValue() const
    {
        return defaultBand6SidechainPreampValue_helper();
    }

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

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

      if (v != mBand7SidechainPreamp && !isBand7SidechainPreampImmutable()) {
        mBand7SidechainPreamp = v;
        Q_EMIT band7SidechainPreampChanged();
      }
    }

    Q_PROPERTY(double band7SidechainPreamp READ band7SidechainPreamp WRITE setBand7SidechainPreamp NOTIFY band7SidechainPreampChanged)
    Q_PROPERTY(bool isBand7SidechainPreampImmutable READ isBand7SidechainPreampImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7SidechainPreampValue READ defaultBand7SidechainPreampValue CONSTANT)
    /**
      Get band7SidechainPreamp
    */
    double band7SidechainPreamp() const
    {
      return mBand7SidechainPreamp;
    }

    /**
      Is band7SidechainPreamp Immutable
    */
    bool isBand7SidechainPreampImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainPreamp" ) );
    }

    /**
      Get band7SidechainPreamp default value
    */
    double defaultBand7SidechainPreampValue() const
    {
        return defaultBand7SidechainPreampValue_helper();
    }

    /**
      Set band0SidechainCustomLowcutFilter
    */
    void setBand0SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand0SidechainCustomLowcutFilter && !isBand0SidechainCustomLowcutFilterImmutable()) {
        mBand0SidechainCustomLowcutFilter = v;
        Q_EMIT band0SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band0SidechainCustomLowcutFilter READ band0SidechainCustomLowcutFilter WRITE setBand0SidechainCustomLowcutFilter NOTIFY band0SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand0SidechainCustomLowcutFilterImmutable READ isBand0SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand0SidechainCustomLowcutFilterValue READ defaultBand0SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band0SidechainCustomLowcutFilter
    */
    bool band0SidechainCustomLowcutFilter() const
    {
      return mBand0SidechainCustomLowcutFilter;
    }

    /**
      Is band0SidechainCustomLowcutFilter Immutable
    */
    bool isBand0SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band0SidechainCustomLowcutFilter default value
    */
    bool defaultBand0SidechainCustomLowcutFilterValue() const
    {
        return defaultBand0SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band1SidechainCustomLowcutFilter
    */
    void setBand1SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand1SidechainCustomLowcutFilter && !isBand1SidechainCustomLowcutFilterImmutable()) {
        mBand1SidechainCustomLowcutFilter = v;
        Q_EMIT band1SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band1SidechainCustomLowcutFilter READ band1SidechainCustomLowcutFilter WRITE setBand1SidechainCustomLowcutFilter NOTIFY band1SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand1SidechainCustomLowcutFilterImmutable READ isBand1SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand1SidechainCustomLowcutFilterValue READ defaultBand1SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band1SidechainCustomLowcutFilter
    */
    bool band1SidechainCustomLowcutFilter() const
    {
      return mBand1SidechainCustomLowcutFilter;
    }

    /**
      Is band1SidechainCustomLowcutFilter Immutable
    */
    bool isBand1SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band1SidechainCustomLowcutFilter default value
    */
    bool defaultBand1SidechainCustomLowcutFilterValue() const
    {
        return defaultBand1SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band2SidechainCustomLowcutFilter
    */
    void setBand2SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand2SidechainCustomLowcutFilter && !isBand2SidechainCustomLowcutFilterImmutable()) {
        mBand2SidechainCustomLowcutFilter = v;
        Q_EMIT band2SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band2SidechainCustomLowcutFilter READ band2SidechainCustomLowcutFilter WRITE setBand2SidechainCustomLowcutFilter NOTIFY band2SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand2SidechainCustomLowcutFilterImmutable READ isBand2SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand2SidechainCustomLowcutFilterValue READ defaultBand2SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band2SidechainCustomLowcutFilter
    */
    bool band2SidechainCustomLowcutFilter() const
    {
      return mBand2SidechainCustomLowcutFilter;
    }

    /**
      Is band2SidechainCustomLowcutFilter Immutable
    */
    bool isBand2SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band2SidechainCustomLowcutFilter default value
    */
    bool defaultBand2SidechainCustomLowcutFilterValue() const
    {
        return defaultBand2SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band3SidechainCustomLowcutFilter
    */
    void setBand3SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand3SidechainCustomLowcutFilter && !isBand3SidechainCustomLowcutFilterImmutable()) {
        mBand3SidechainCustomLowcutFilter = v;
        Q_EMIT band3SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band3SidechainCustomLowcutFilter READ band3SidechainCustomLowcutFilter WRITE setBand3SidechainCustomLowcutFilter NOTIFY band3SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand3SidechainCustomLowcutFilterImmutable READ isBand3SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand3SidechainCustomLowcutFilterValue READ defaultBand3SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band3SidechainCustomLowcutFilter
    */
    bool band3SidechainCustomLowcutFilter() const
    {
      return mBand3SidechainCustomLowcutFilter;
    }

    /**
      Is band3SidechainCustomLowcutFilter Immutable
    */
    bool isBand3SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band3SidechainCustomLowcutFilter default value
    */
    bool defaultBand3SidechainCustomLowcutFilterValue() const
    {
        return defaultBand3SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band4SidechainCustomLowcutFilter
    */
    void setBand4SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand4SidechainCustomLowcutFilter && !isBand4SidechainCustomLowcutFilterImmutable()) {
        mBand4SidechainCustomLowcutFilter = v;
        Q_EMIT band4SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band4SidechainCustomLowcutFilter READ band4SidechainCustomLowcutFilter WRITE setBand4SidechainCustomLowcutFilter NOTIFY band4SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand4SidechainCustomLowcutFilterImmutable READ isBand4SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand4SidechainCustomLowcutFilterValue READ defaultBand4SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band4SidechainCustomLowcutFilter
    */
    bool band4SidechainCustomLowcutFilter() const
    {
      return mBand4SidechainCustomLowcutFilter;
    }

    /**
      Is band4SidechainCustomLowcutFilter Immutable
    */
    bool isBand4SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band4SidechainCustomLowcutFilter default value
    */
    bool defaultBand4SidechainCustomLowcutFilterValue() const
    {
        return defaultBand4SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band5SidechainCustomLowcutFilter
    */
    void setBand5SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand5SidechainCustomLowcutFilter && !isBand5SidechainCustomLowcutFilterImmutable()) {
        mBand5SidechainCustomLowcutFilter = v;
        Q_EMIT band5SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band5SidechainCustomLowcutFilter READ band5SidechainCustomLowcutFilter WRITE setBand5SidechainCustomLowcutFilter NOTIFY band5SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand5SidechainCustomLowcutFilterImmutable READ isBand5SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand5SidechainCustomLowcutFilterValue READ defaultBand5SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band5SidechainCustomLowcutFilter
    */
    bool band5SidechainCustomLowcutFilter() const
    {
      return mBand5SidechainCustomLowcutFilter;
    }

    /**
      Is band5SidechainCustomLowcutFilter Immutable
    */
    bool isBand5SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band5SidechainCustomLowcutFilter default value
    */
    bool defaultBand5SidechainCustomLowcutFilterValue() const
    {
        return defaultBand5SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band6SidechainCustomLowcutFilter
    */
    void setBand6SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand6SidechainCustomLowcutFilter && !isBand6SidechainCustomLowcutFilterImmutable()) {
        mBand6SidechainCustomLowcutFilter = v;
        Q_EMIT band6SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band6SidechainCustomLowcutFilter READ band6SidechainCustomLowcutFilter WRITE setBand6SidechainCustomLowcutFilter NOTIFY band6SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand6SidechainCustomLowcutFilterImmutable READ isBand6SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand6SidechainCustomLowcutFilterValue READ defaultBand6SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band6SidechainCustomLowcutFilter
    */
    bool band6SidechainCustomLowcutFilter() const
    {
      return mBand6SidechainCustomLowcutFilter;
    }

    /**
      Is band6SidechainCustomLowcutFilter Immutable
    */
    bool isBand6SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band6SidechainCustomLowcutFilter default value
    */
    bool defaultBand6SidechainCustomLowcutFilterValue() const
    {
        return defaultBand6SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band7SidechainCustomLowcutFilter
    */
    void setBand7SidechainCustomLowcutFilter( bool v )
    {
      if (v != mBand7SidechainCustomLowcutFilter && !isBand7SidechainCustomLowcutFilterImmutable()) {
        mBand7SidechainCustomLowcutFilter = v;
        Q_EMIT band7SidechainCustomLowcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band7SidechainCustomLowcutFilter READ band7SidechainCustomLowcutFilter WRITE setBand7SidechainCustomLowcutFilter NOTIFY band7SidechainCustomLowcutFilterChanged)
    Q_PROPERTY(bool isBand7SidechainCustomLowcutFilterImmutable READ isBand7SidechainCustomLowcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand7SidechainCustomLowcutFilterValue READ defaultBand7SidechainCustomLowcutFilterValue CONSTANT)
    /**
      Get band7SidechainCustomLowcutFilter
    */
    bool band7SidechainCustomLowcutFilter() const
    {
      return mBand7SidechainCustomLowcutFilter;
    }

    /**
      Is band7SidechainCustomLowcutFilter Immutable
    */
    bool isBand7SidechainCustomLowcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainCustomLowcutFilter" ) );
    }

    /**
      Get band7SidechainCustomLowcutFilter default value
    */
    bool defaultBand7SidechainCustomLowcutFilterValue() const
    {
        return defaultBand7SidechainCustomLowcutFilterValue_helper();
    }

    /**
      Set band0SidechainCustomHighcutFilter
    */
    void setBand0SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand0SidechainCustomHighcutFilter && !isBand0SidechainCustomHighcutFilterImmutable()) {
        mBand0SidechainCustomHighcutFilter = v;
        Q_EMIT band0SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band0SidechainCustomHighcutFilter READ band0SidechainCustomHighcutFilter WRITE setBand0SidechainCustomHighcutFilter NOTIFY band0SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand0SidechainCustomHighcutFilterImmutable READ isBand0SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand0SidechainCustomHighcutFilterValue READ defaultBand0SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band0SidechainCustomHighcutFilter
    */
    bool band0SidechainCustomHighcutFilter() const
    {
      return mBand0SidechainCustomHighcutFilter;
    }

    /**
      Is band0SidechainCustomHighcutFilter Immutable
    */
    bool isBand0SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band0SidechainCustomHighcutFilter default value
    */
    bool defaultBand0SidechainCustomHighcutFilterValue() const
    {
        return defaultBand0SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band1SidechainCustomHighcutFilter
    */
    void setBand1SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand1SidechainCustomHighcutFilter && !isBand1SidechainCustomHighcutFilterImmutable()) {
        mBand1SidechainCustomHighcutFilter = v;
        Q_EMIT band1SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band1SidechainCustomHighcutFilter READ band1SidechainCustomHighcutFilter WRITE setBand1SidechainCustomHighcutFilter NOTIFY band1SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand1SidechainCustomHighcutFilterImmutable READ isBand1SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand1SidechainCustomHighcutFilterValue READ defaultBand1SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band1SidechainCustomHighcutFilter
    */
    bool band1SidechainCustomHighcutFilter() const
    {
      return mBand1SidechainCustomHighcutFilter;
    }

    /**
      Is band1SidechainCustomHighcutFilter Immutable
    */
    bool isBand1SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band1SidechainCustomHighcutFilter default value
    */
    bool defaultBand1SidechainCustomHighcutFilterValue() const
    {
        return defaultBand1SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band2SidechainCustomHighcutFilter
    */
    void setBand2SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand2SidechainCustomHighcutFilter && !isBand2SidechainCustomHighcutFilterImmutable()) {
        mBand2SidechainCustomHighcutFilter = v;
        Q_EMIT band2SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band2SidechainCustomHighcutFilter READ band2SidechainCustomHighcutFilter WRITE setBand2SidechainCustomHighcutFilter NOTIFY band2SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand2SidechainCustomHighcutFilterImmutable READ isBand2SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand2SidechainCustomHighcutFilterValue READ defaultBand2SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band2SidechainCustomHighcutFilter
    */
    bool band2SidechainCustomHighcutFilter() const
    {
      return mBand2SidechainCustomHighcutFilter;
    }

    /**
      Is band2SidechainCustomHighcutFilter Immutable
    */
    bool isBand2SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band2SidechainCustomHighcutFilter default value
    */
    bool defaultBand2SidechainCustomHighcutFilterValue() const
    {
        return defaultBand2SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band3SidechainCustomHighcutFilter
    */
    void setBand3SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand3SidechainCustomHighcutFilter && !isBand3SidechainCustomHighcutFilterImmutable()) {
        mBand3SidechainCustomHighcutFilter = v;
        Q_EMIT band3SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band3SidechainCustomHighcutFilter READ band3SidechainCustomHighcutFilter WRITE setBand3SidechainCustomHighcutFilter NOTIFY band3SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand3SidechainCustomHighcutFilterImmutable READ isBand3SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand3SidechainCustomHighcutFilterValue READ defaultBand3SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band3SidechainCustomHighcutFilter
    */
    bool band3SidechainCustomHighcutFilter() const
    {
      return mBand3SidechainCustomHighcutFilter;
    }

    /**
      Is band3SidechainCustomHighcutFilter Immutable
    */
    bool isBand3SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band3SidechainCustomHighcutFilter default value
    */
    bool defaultBand3SidechainCustomHighcutFilterValue() const
    {
        return defaultBand3SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band4SidechainCustomHighcutFilter
    */
    void setBand4SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand4SidechainCustomHighcutFilter && !isBand4SidechainCustomHighcutFilterImmutable()) {
        mBand4SidechainCustomHighcutFilter = v;
        Q_EMIT band4SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band4SidechainCustomHighcutFilter READ band4SidechainCustomHighcutFilter WRITE setBand4SidechainCustomHighcutFilter NOTIFY band4SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand4SidechainCustomHighcutFilterImmutable READ isBand4SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand4SidechainCustomHighcutFilterValue READ defaultBand4SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band4SidechainCustomHighcutFilter
    */
    bool band4SidechainCustomHighcutFilter() const
    {
      return mBand4SidechainCustomHighcutFilter;
    }

    /**
      Is band4SidechainCustomHighcutFilter Immutable
    */
    bool isBand4SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band4SidechainCustomHighcutFilter default value
    */
    bool defaultBand4SidechainCustomHighcutFilterValue() const
    {
        return defaultBand4SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band5SidechainCustomHighcutFilter
    */
    void setBand5SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand5SidechainCustomHighcutFilter && !isBand5SidechainCustomHighcutFilterImmutable()) {
        mBand5SidechainCustomHighcutFilter = v;
        Q_EMIT band5SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band5SidechainCustomHighcutFilter READ band5SidechainCustomHighcutFilter WRITE setBand5SidechainCustomHighcutFilter NOTIFY band5SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand5SidechainCustomHighcutFilterImmutable READ isBand5SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand5SidechainCustomHighcutFilterValue READ defaultBand5SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band5SidechainCustomHighcutFilter
    */
    bool band5SidechainCustomHighcutFilter() const
    {
      return mBand5SidechainCustomHighcutFilter;
    }

    /**
      Is band5SidechainCustomHighcutFilter Immutable
    */
    bool isBand5SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band5SidechainCustomHighcutFilter default value
    */
    bool defaultBand5SidechainCustomHighcutFilterValue() const
    {
        return defaultBand5SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band6SidechainCustomHighcutFilter
    */
    void setBand6SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand6SidechainCustomHighcutFilter && !isBand6SidechainCustomHighcutFilterImmutable()) {
        mBand6SidechainCustomHighcutFilter = v;
        Q_EMIT band6SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band6SidechainCustomHighcutFilter READ band6SidechainCustomHighcutFilter WRITE setBand6SidechainCustomHighcutFilter NOTIFY band6SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand6SidechainCustomHighcutFilterImmutable READ isBand6SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand6SidechainCustomHighcutFilterValue READ defaultBand6SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band6SidechainCustomHighcutFilter
    */
    bool band6SidechainCustomHighcutFilter() const
    {
      return mBand6SidechainCustomHighcutFilter;
    }

    /**
      Is band6SidechainCustomHighcutFilter Immutable
    */
    bool isBand6SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band6SidechainCustomHighcutFilter default value
    */
    bool defaultBand6SidechainCustomHighcutFilterValue() const
    {
        return defaultBand6SidechainCustomHighcutFilterValue_helper();
    }

    /**
      Set band7SidechainCustomHighcutFilter
    */
    void setBand7SidechainCustomHighcutFilter( bool v )
    {
      if (v != mBand7SidechainCustomHighcutFilter && !isBand7SidechainCustomHighcutFilterImmutable()) {
        mBand7SidechainCustomHighcutFilter = v;
        Q_EMIT band7SidechainCustomHighcutFilterChanged();
      }
    }

    Q_PROPERTY(bool band7SidechainCustomHighcutFilter READ band7SidechainCustomHighcutFilter WRITE setBand7SidechainCustomHighcutFilter NOTIFY band7SidechainCustomHighcutFilterChanged)
    Q_PROPERTY(bool isBand7SidechainCustomHighcutFilterImmutable READ isBand7SidechainCustomHighcutFilterImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand7SidechainCustomHighcutFilterValue READ defaultBand7SidechainCustomHighcutFilterValue CONSTANT)
    /**
      Get band7SidechainCustomHighcutFilter
    */
    bool band7SidechainCustomHighcutFilter() const
    {
      return mBand7SidechainCustomHighcutFilter;
    }

    /**
      Is band7SidechainCustomHighcutFilter Immutable
    */
    bool isBand7SidechainCustomHighcutFilterImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainCustomHighcutFilter" ) );
    }

    /**
      Get band7SidechainCustomHighcutFilter default value
    */
    bool defaultBand7SidechainCustomHighcutFilterValue() const
    {
        return defaultBand7SidechainCustomHighcutFilterValue_helper();
    }

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

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

      if (v != mBand0SidechainLowcutFrequency && !isBand0SidechainLowcutFrequencyImmutable()) {
        mBand0SidechainLowcutFrequency = v;
        Q_EMIT band0SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band0SidechainLowcutFrequency READ band0SidechainLowcutFrequency WRITE setBand0SidechainLowcutFrequency NOTIFY band0SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand0SidechainLowcutFrequencyImmutable READ isBand0SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0SidechainLowcutFrequencyValue READ defaultBand0SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band0SidechainLowcutFrequency
    */
    double band0SidechainLowcutFrequency() const
    {
      return mBand0SidechainLowcutFrequency;
    }

    /**
      Is band0SidechainLowcutFrequency Immutable
    */
    bool isBand0SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainLowcutFrequency" ) );
    }

    /**
      Get band0SidechainLowcutFrequency default value
    */
    double defaultBand0SidechainLowcutFrequencyValue() const
    {
        return defaultBand0SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand1SidechainLowcutFrequency && !isBand1SidechainLowcutFrequencyImmutable()) {
        mBand1SidechainLowcutFrequency = v;
        Q_EMIT band1SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band1SidechainLowcutFrequency READ band1SidechainLowcutFrequency WRITE setBand1SidechainLowcutFrequency NOTIFY band1SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand1SidechainLowcutFrequencyImmutable READ isBand1SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1SidechainLowcutFrequencyValue READ defaultBand1SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band1SidechainLowcutFrequency
    */
    double band1SidechainLowcutFrequency() const
    {
      return mBand1SidechainLowcutFrequency;
    }

    /**
      Is band1SidechainLowcutFrequency Immutable
    */
    bool isBand1SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainLowcutFrequency" ) );
    }

    /**
      Get band1SidechainLowcutFrequency default value
    */
    double defaultBand1SidechainLowcutFrequencyValue() const
    {
        return defaultBand1SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand2SidechainLowcutFrequency && !isBand2SidechainLowcutFrequencyImmutable()) {
        mBand2SidechainLowcutFrequency = v;
        Q_EMIT band2SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band2SidechainLowcutFrequency READ band2SidechainLowcutFrequency WRITE setBand2SidechainLowcutFrequency NOTIFY band2SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand2SidechainLowcutFrequencyImmutable READ isBand2SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2SidechainLowcutFrequencyValue READ defaultBand2SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band2SidechainLowcutFrequency
    */
    double band2SidechainLowcutFrequency() const
    {
      return mBand2SidechainLowcutFrequency;
    }

    /**
      Is band2SidechainLowcutFrequency Immutable
    */
    bool isBand2SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainLowcutFrequency" ) );
    }

    /**
      Get band2SidechainLowcutFrequency default value
    */
    double defaultBand2SidechainLowcutFrequencyValue() const
    {
        return defaultBand2SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand3SidechainLowcutFrequency && !isBand3SidechainLowcutFrequencyImmutable()) {
        mBand3SidechainLowcutFrequency = v;
        Q_EMIT band3SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band3SidechainLowcutFrequency READ band3SidechainLowcutFrequency WRITE setBand3SidechainLowcutFrequency NOTIFY band3SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand3SidechainLowcutFrequencyImmutable READ isBand3SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3SidechainLowcutFrequencyValue READ defaultBand3SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band3SidechainLowcutFrequency
    */
    double band3SidechainLowcutFrequency() const
    {
      return mBand3SidechainLowcutFrequency;
    }

    /**
      Is band3SidechainLowcutFrequency Immutable
    */
    bool isBand3SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainLowcutFrequency" ) );
    }

    /**
      Get band3SidechainLowcutFrequency default value
    */
    double defaultBand3SidechainLowcutFrequencyValue() const
    {
        return defaultBand3SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand4SidechainLowcutFrequency && !isBand4SidechainLowcutFrequencyImmutable()) {
        mBand4SidechainLowcutFrequency = v;
        Q_EMIT band4SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band4SidechainLowcutFrequency READ band4SidechainLowcutFrequency WRITE setBand4SidechainLowcutFrequency NOTIFY band4SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand4SidechainLowcutFrequencyImmutable READ isBand4SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4SidechainLowcutFrequencyValue READ defaultBand4SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band4SidechainLowcutFrequency
    */
    double band4SidechainLowcutFrequency() const
    {
      return mBand4SidechainLowcutFrequency;
    }

    /**
      Is band4SidechainLowcutFrequency Immutable
    */
    bool isBand4SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainLowcutFrequency" ) );
    }

    /**
      Get band4SidechainLowcutFrequency default value
    */
    double defaultBand4SidechainLowcutFrequencyValue() const
    {
        return defaultBand4SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand5SidechainLowcutFrequency && !isBand5SidechainLowcutFrequencyImmutable()) {
        mBand5SidechainLowcutFrequency = v;
        Q_EMIT band5SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band5SidechainLowcutFrequency READ band5SidechainLowcutFrequency WRITE setBand5SidechainLowcutFrequency NOTIFY band5SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand5SidechainLowcutFrequencyImmutable READ isBand5SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5SidechainLowcutFrequencyValue READ defaultBand5SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band5SidechainLowcutFrequency
    */
    double band5SidechainLowcutFrequency() const
    {
      return mBand5SidechainLowcutFrequency;
    }

    /**
      Is band5SidechainLowcutFrequency Immutable
    */
    bool isBand5SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainLowcutFrequency" ) );
    }

    /**
      Get band5SidechainLowcutFrequency default value
    */
    double defaultBand5SidechainLowcutFrequencyValue() const
    {
        return defaultBand5SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand6SidechainLowcutFrequency && !isBand6SidechainLowcutFrequencyImmutable()) {
        mBand6SidechainLowcutFrequency = v;
        Q_EMIT band6SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band6SidechainLowcutFrequency READ band6SidechainLowcutFrequency WRITE setBand6SidechainLowcutFrequency NOTIFY band6SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand6SidechainLowcutFrequencyImmutable READ isBand6SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6SidechainLowcutFrequencyValue READ defaultBand6SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band6SidechainLowcutFrequency
    */
    double band6SidechainLowcutFrequency() const
    {
      return mBand6SidechainLowcutFrequency;
    }

    /**
      Is band6SidechainLowcutFrequency Immutable
    */
    bool isBand6SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainLowcutFrequency" ) );
    }

    /**
      Get band6SidechainLowcutFrequency default value
    */
    double defaultBand6SidechainLowcutFrequencyValue() const
    {
        return defaultBand6SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand7SidechainLowcutFrequency && !isBand7SidechainLowcutFrequencyImmutable()) {
        mBand7SidechainLowcutFrequency = v;
        Q_EMIT band7SidechainLowcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band7SidechainLowcutFrequency READ band7SidechainLowcutFrequency WRITE setBand7SidechainLowcutFrequency NOTIFY band7SidechainLowcutFrequencyChanged)
    Q_PROPERTY(bool isBand7SidechainLowcutFrequencyImmutable READ isBand7SidechainLowcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7SidechainLowcutFrequencyValue READ defaultBand7SidechainLowcutFrequencyValue CONSTANT)
    /**
      Get band7SidechainLowcutFrequency
    */
    double band7SidechainLowcutFrequency() const
    {
      return mBand7SidechainLowcutFrequency;
    }

    /**
      Is band7SidechainLowcutFrequency Immutable
    */
    bool isBand7SidechainLowcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainLowcutFrequency" ) );
    }

    /**
      Get band7SidechainLowcutFrequency default value
    */
    double defaultBand7SidechainLowcutFrequencyValue() const
    {
        return defaultBand7SidechainLowcutFrequencyValue_helper();
    }

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

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

      if (v != mBand0SidechainHighcutFrequency && !isBand0SidechainHighcutFrequencyImmutable()) {
        mBand0SidechainHighcutFrequency = v;
        Q_EMIT band0SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band0SidechainHighcutFrequency READ band0SidechainHighcutFrequency WRITE setBand0SidechainHighcutFrequency NOTIFY band0SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand0SidechainHighcutFrequencyImmutable READ isBand0SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0SidechainHighcutFrequencyValue READ defaultBand0SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band0SidechainHighcutFrequency
    */
    double band0SidechainHighcutFrequency() const
    {
      return mBand0SidechainHighcutFrequency;
    }

    /**
      Is band0SidechainHighcutFrequency Immutable
    */
    bool isBand0SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band0SidechainHighcutFrequency" ) );
    }

    /**
      Get band0SidechainHighcutFrequency default value
    */
    double defaultBand0SidechainHighcutFrequencyValue() const
    {
        return defaultBand0SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand1SidechainHighcutFrequency && !isBand1SidechainHighcutFrequencyImmutable()) {
        mBand1SidechainHighcutFrequency = v;
        Q_EMIT band1SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band1SidechainHighcutFrequency READ band1SidechainHighcutFrequency WRITE setBand1SidechainHighcutFrequency NOTIFY band1SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand1SidechainHighcutFrequencyImmutable READ isBand1SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1SidechainHighcutFrequencyValue READ defaultBand1SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band1SidechainHighcutFrequency
    */
    double band1SidechainHighcutFrequency() const
    {
      return mBand1SidechainHighcutFrequency;
    }

    /**
      Is band1SidechainHighcutFrequency Immutable
    */
    bool isBand1SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band1SidechainHighcutFrequency" ) );
    }

    /**
      Get band1SidechainHighcutFrequency default value
    */
    double defaultBand1SidechainHighcutFrequencyValue() const
    {
        return defaultBand1SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand2SidechainHighcutFrequency && !isBand2SidechainHighcutFrequencyImmutable()) {
        mBand2SidechainHighcutFrequency = v;
        Q_EMIT band2SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band2SidechainHighcutFrequency READ band2SidechainHighcutFrequency WRITE setBand2SidechainHighcutFrequency NOTIFY band2SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand2SidechainHighcutFrequencyImmutable READ isBand2SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2SidechainHighcutFrequencyValue READ defaultBand2SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band2SidechainHighcutFrequency
    */
    double band2SidechainHighcutFrequency() const
    {
      return mBand2SidechainHighcutFrequency;
    }

    /**
      Is band2SidechainHighcutFrequency Immutable
    */
    bool isBand2SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band2SidechainHighcutFrequency" ) );
    }

    /**
      Get band2SidechainHighcutFrequency default value
    */
    double defaultBand2SidechainHighcutFrequencyValue() const
    {
        return defaultBand2SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand3SidechainHighcutFrequency && !isBand3SidechainHighcutFrequencyImmutable()) {
        mBand3SidechainHighcutFrequency = v;
        Q_EMIT band3SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band3SidechainHighcutFrequency READ band3SidechainHighcutFrequency WRITE setBand3SidechainHighcutFrequency NOTIFY band3SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand3SidechainHighcutFrequencyImmutable READ isBand3SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3SidechainHighcutFrequencyValue READ defaultBand3SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band3SidechainHighcutFrequency
    */
    double band3SidechainHighcutFrequency() const
    {
      return mBand3SidechainHighcutFrequency;
    }

    /**
      Is band3SidechainHighcutFrequency Immutable
    */
    bool isBand3SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band3SidechainHighcutFrequency" ) );
    }

    /**
      Get band3SidechainHighcutFrequency default value
    */
    double defaultBand3SidechainHighcutFrequencyValue() const
    {
        return defaultBand3SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand4SidechainHighcutFrequency && !isBand4SidechainHighcutFrequencyImmutable()) {
        mBand4SidechainHighcutFrequency = v;
        Q_EMIT band4SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band4SidechainHighcutFrequency READ band4SidechainHighcutFrequency WRITE setBand4SidechainHighcutFrequency NOTIFY band4SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand4SidechainHighcutFrequencyImmutable READ isBand4SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4SidechainHighcutFrequencyValue READ defaultBand4SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band4SidechainHighcutFrequency
    */
    double band4SidechainHighcutFrequency() const
    {
      return mBand4SidechainHighcutFrequency;
    }

    /**
      Is band4SidechainHighcutFrequency Immutable
    */
    bool isBand4SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band4SidechainHighcutFrequency" ) );
    }

    /**
      Get band4SidechainHighcutFrequency default value
    */
    double defaultBand4SidechainHighcutFrequencyValue() const
    {
        return defaultBand4SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand5SidechainHighcutFrequency && !isBand5SidechainHighcutFrequencyImmutable()) {
        mBand5SidechainHighcutFrequency = v;
        Q_EMIT band5SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band5SidechainHighcutFrequency READ band5SidechainHighcutFrequency WRITE setBand5SidechainHighcutFrequency NOTIFY band5SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand5SidechainHighcutFrequencyImmutable READ isBand5SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5SidechainHighcutFrequencyValue READ defaultBand5SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band5SidechainHighcutFrequency
    */
    double band5SidechainHighcutFrequency() const
    {
      return mBand5SidechainHighcutFrequency;
    }

    /**
      Is band5SidechainHighcutFrequency Immutable
    */
    bool isBand5SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band5SidechainHighcutFrequency" ) );
    }

    /**
      Get band5SidechainHighcutFrequency default value
    */
    double defaultBand5SidechainHighcutFrequencyValue() const
    {
        return defaultBand5SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand6SidechainHighcutFrequency && !isBand6SidechainHighcutFrequencyImmutable()) {
        mBand6SidechainHighcutFrequency = v;
        Q_EMIT band6SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band6SidechainHighcutFrequency READ band6SidechainHighcutFrequency WRITE setBand6SidechainHighcutFrequency NOTIFY band6SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand6SidechainHighcutFrequencyImmutable READ isBand6SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6SidechainHighcutFrequencyValue READ defaultBand6SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band6SidechainHighcutFrequency
    */
    double band6SidechainHighcutFrequency() const
    {
      return mBand6SidechainHighcutFrequency;
    }

    /**
      Is band6SidechainHighcutFrequency Immutable
    */
    bool isBand6SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band6SidechainHighcutFrequency" ) );
    }

    /**
      Get band6SidechainHighcutFrequency default value
    */
    double defaultBand6SidechainHighcutFrequencyValue() const
    {
        return defaultBand6SidechainHighcutFrequencyValue_helper();
    }

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

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

      if (v != mBand7SidechainHighcutFrequency && !isBand7SidechainHighcutFrequencyImmutable()) {
        mBand7SidechainHighcutFrequency = v;
        Q_EMIT band7SidechainHighcutFrequencyChanged();
      }
    }

    Q_PROPERTY(double band7SidechainHighcutFrequency READ band7SidechainHighcutFrequency WRITE setBand7SidechainHighcutFrequency NOTIFY band7SidechainHighcutFrequencyChanged)
    Q_PROPERTY(bool isBand7SidechainHighcutFrequencyImmutable READ isBand7SidechainHighcutFrequencyImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7SidechainHighcutFrequencyValue READ defaultBand7SidechainHighcutFrequencyValue CONSTANT)
    /**
      Get band7SidechainHighcutFrequency
    */
    double band7SidechainHighcutFrequency() const
    {
      return mBand7SidechainHighcutFrequency;
    }

    /**
      Is band7SidechainHighcutFrequency Immutable
    */
    bool isBand7SidechainHighcutFrequencyImmutable() const
    {
      return isImmutable( QStringLiteral( "band7SidechainHighcutFrequency" ) );
    }

    /**
      Get band7SidechainHighcutFrequency default value
    */
    double defaultBand7SidechainHighcutFrequencyValue() const
    {
        return defaultBand7SidechainHighcutFrequencyValue_helper();
    }

    /**
      Set compressionModeLabels
    */
    void setCompressionModeLabels( const QStringList & v )
    {
      if (v != mCompressionModeLabels && !isCompressionModeLabelsImmutable()) {
        mCompressionModeLabels = v;
        Q_EMIT compressionModeLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList compressionModeLabels READ compressionModeLabels WRITE setCompressionModeLabels NOTIFY compressionModeLabelsChanged)
    Q_PROPERTY(bool isCompressionModeLabelsImmutable READ isCompressionModeLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultCompressionModeLabelsValue READ defaultCompressionModeLabelsValue CONSTANT)
    /**
      Get compressionModeLabels
    */
    QStringList compressionModeLabels() const
    {
      return mCompressionModeLabels;
    }

    /**
      Is compressionModeLabels Immutable
    */
    bool isCompressionModeLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "compressionModeLabels" ) );
    }

    /**
      Get compressionModeLabels default value
    */
    QStringList defaultCompressionModeLabelsValue() const
    {
        return defaultCompressionModeLabelsValue_helper();
    }

    /**
      Set band0CompressionMode
    */
    void setBand0CompressionMode( int v )
    {
      if (v != mBand0CompressionMode && !isBand0CompressionModeImmutable()) {
        mBand0CompressionMode = v;
        Q_EMIT band0CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band0CompressionMode READ band0CompressionMode WRITE setBand0CompressionMode NOTIFY band0CompressionModeChanged)
    Q_PROPERTY(bool isBand0CompressionModeImmutable READ isBand0CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand0CompressionModeValue READ defaultBand0CompressionModeValue CONSTANT)
    /**
      Get band0CompressionMode
    */
    int band0CompressionMode() const
    {
      return mBand0CompressionMode;
    }

    /**
      Is band0CompressionMode Immutable
    */
    bool isBand0CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band0CompressionMode" ) );
    }

    /**
      Get band0CompressionMode default value
    */
    int defaultBand0CompressionModeValue() const
    {
        return defaultBand0CompressionModeValue_helper();
    }

    /**
      Set band1CompressionMode
    */
    void setBand1CompressionMode( int v )
    {
      if (v != mBand1CompressionMode && !isBand1CompressionModeImmutable()) {
        mBand1CompressionMode = v;
        Q_EMIT band1CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band1CompressionMode READ band1CompressionMode WRITE setBand1CompressionMode NOTIFY band1CompressionModeChanged)
    Q_PROPERTY(bool isBand1CompressionModeImmutable READ isBand1CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand1CompressionModeValue READ defaultBand1CompressionModeValue CONSTANT)
    /**
      Get band1CompressionMode
    */
    int band1CompressionMode() const
    {
      return mBand1CompressionMode;
    }

    /**
      Is band1CompressionMode Immutable
    */
    bool isBand1CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band1CompressionMode" ) );
    }

    /**
      Get band1CompressionMode default value
    */
    int defaultBand1CompressionModeValue() const
    {
        return defaultBand1CompressionModeValue_helper();
    }

    /**
      Set band2CompressionMode
    */
    void setBand2CompressionMode( int v )
    {
      if (v != mBand2CompressionMode && !isBand2CompressionModeImmutable()) {
        mBand2CompressionMode = v;
        Q_EMIT band2CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band2CompressionMode READ band2CompressionMode WRITE setBand2CompressionMode NOTIFY band2CompressionModeChanged)
    Q_PROPERTY(bool isBand2CompressionModeImmutable READ isBand2CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand2CompressionModeValue READ defaultBand2CompressionModeValue CONSTANT)
    /**
      Get band2CompressionMode
    */
    int band2CompressionMode() const
    {
      return mBand2CompressionMode;
    }

    /**
      Is band2CompressionMode Immutable
    */
    bool isBand2CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band2CompressionMode" ) );
    }

    /**
      Get band2CompressionMode default value
    */
    int defaultBand2CompressionModeValue() const
    {
        return defaultBand2CompressionModeValue_helper();
    }

    /**
      Set band3CompressionMode
    */
    void setBand3CompressionMode( int v )
    {
      if (v != mBand3CompressionMode && !isBand3CompressionModeImmutable()) {
        mBand3CompressionMode = v;
        Q_EMIT band3CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band3CompressionMode READ band3CompressionMode WRITE setBand3CompressionMode NOTIFY band3CompressionModeChanged)
    Q_PROPERTY(bool isBand3CompressionModeImmutable READ isBand3CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand3CompressionModeValue READ defaultBand3CompressionModeValue CONSTANT)
    /**
      Get band3CompressionMode
    */
    int band3CompressionMode() const
    {
      return mBand3CompressionMode;
    }

    /**
      Is band3CompressionMode Immutable
    */
    bool isBand3CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band3CompressionMode" ) );
    }

    /**
      Get band3CompressionMode default value
    */
    int defaultBand3CompressionModeValue() const
    {
        return defaultBand3CompressionModeValue_helper();
    }

    /**
      Set band4CompressionMode
    */
    void setBand4CompressionMode( int v )
    {
      if (v != mBand4CompressionMode && !isBand4CompressionModeImmutable()) {
        mBand4CompressionMode = v;
        Q_EMIT band4CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band4CompressionMode READ band4CompressionMode WRITE setBand4CompressionMode NOTIFY band4CompressionModeChanged)
    Q_PROPERTY(bool isBand4CompressionModeImmutable READ isBand4CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand4CompressionModeValue READ defaultBand4CompressionModeValue CONSTANT)
    /**
      Get band4CompressionMode
    */
    int band4CompressionMode() const
    {
      return mBand4CompressionMode;
    }

    /**
      Is band4CompressionMode Immutable
    */
    bool isBand4CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band4CompressionMode" ) );
    }

    /**
      Get band4CompressionMode default value
    */
    int defaultBand4CompressionModeValue() const
    {
        return defaultBand4CompressionModeValue_helper();
    }

    /**
      Set band5CompressionMode
    */
    void setBand5CompressionMode( int v )
    {
      if (v != mBand5CompressionMode && !isBand5CompressionModeImmutable()) {
        mBand5CompressionMode = v;
        Q_EMIT band5CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band5CompressionMode READ band5CompressionMode WRITE setBand5CompressionMode NOTIFY band5CompressionModeChanged)
    Q_PROPERTY(bool isBand5CompressionModeImmutable READ isBand5CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand5CompressionModeValue READ defaultBand5CompressionModeValue CONSTANT)
    /**
      Get band5CompressionMode
    */
    int band5CompressionMode() const
    {
      return mBand5CompressionMode;
    }

    /**
      Is band5CompressionMode Immutable
    */
    bool isBand5CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band5CompressionMode" ) );
    }

    /**
      Get band5CompressionMode default value
    */
    int defaultBand5CompressionModeValue() const
    {
        return defaultBand5CompressionModeValue_helper();
    }

    /**
      Set band6CompressionMode
    */
    void setBand6CompressionMode( int v )
    {
      if (v != mBand6CompressionMode && !isBand6CompressionModeImmutable()) {
        mBand6CompressionMode = v;
        Q_EMIT band6CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band6CompressionMode READ band6CompressionMode WRITE setBand6CompressionMode NOTIFY band6CompressionModeChanged)
    Q_PROPERTY(bool isBand6CompressionModeImmutable READ isBand6CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand6CompressionModeValue READ defaultBand6CompressionModeValue CONSTANT)
    /**
      Get band6CompressionMode
    */
    int band6CompressionMode() const
    {
      return mBand6CompressionMode;
    }

    /**
      Is band6CompressionMode Immutable
    */
    bool isBand6CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band6CompressionMode" ) );
    }

    /**
      Get band6CompressionMode default value
    */
    int defaultBand6CompressionModeValue() const
    {
        return defaultBand6CompressionModeValue_helper();
    }

    /**
      Set band7CompressionMode
    */
    void setBand7CompressionMode( int v )
    {
      if (v != mBand7CompressionMode && !isBand7CompressionModeImmutable()) {
        mBand7CompressionMode = v;
        Q_EMIT band7CompressionModeChanged();
      }
    }

    Q_PROPERTY(int band7CompressionMode READ band7CompressionMode WRITE setBand7CompressionMode NOTIFY band7CompressionModeChanged)
    Q_PROPERTY(bool isBand7CompressionModeImmutable READ isBand7CompressionModeImmutable CONSTANT)
    Q_PROPERTY(int defaultBand7CompressionModeValue READ defaultBand7CompressionModeValue CONSTANT)
    /**
      Get band7CompressionMode
    */
    int band7CompressionMode() const
    {
      return mBand7CompressionMode;
    }

    /**
      Is band7CompressionMode Immutable
    */
    bool isBand7CompressionModeImmutable() const
    {
      return isImmutable( QStringLiteral( "band7CompressionMode" ) );
    }

    /**
      Get band7CompressionMode default value
    */
    int defaultBand7CompressionModeValue() const
    {
        return defaultBand7CompressionModeValue_helper();
    }

    /**
      Set band0CompressorEnable
    */
    void setBand0CompressorEnable( bool v )
    {
      if (v != mBand0CompressorEnable && !isBand0CompressorEnableImmutable()) {
        mBand0CompressorEnable = v;
        Q_EMIT band0CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band0CompressorEnable READ band0CompressorEnable WRITE setBand0CompressorEnable NOTIFY band0CompressorEnableChanged)
    Q_PROPERTY(bool isBand0CompressorEnableImmutable READ isBand0CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand0CompressorEnableValue READ defaultBand0CompressorEnableValue CONSTANT)
    /**
      Get band0CompressorEnable
    */
    bool band0CompressorEnable() const
    {
      return mBand0CompressorEnable;
    }

    /**
      Is band0CompressorEnable Immutable
    */
    bool isBand0CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band0CompressorEnable" ) );
    }

    /**
      Get band0CompressorEnable default value
    */
    bool defaultBand0CompressorEnableValue() const
    {
        return defaultBand0CompressorEnableValue_helper();
    }

    /**
      Set band1CompressorEnable
    */
    void setBand1CompressorEnable( bool v )
    {
      if (v != mBand1CompressorEnable && !isBand1CompressorEnableImmutable()) {
        mBand1CompressorEnable = v;
        Q_EMIT band1CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band1CompressorEnable READ band1CompressorEnable WRITE setBand1CompressorEnable NOTIFY band1CompressorEnableChanged)
    Q_PROPERTY(bool isBand1CompressorEnableImmutable READ isBand1CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand1CompressorEnableValue READ defaultBand1CompressorEnableValue CONSTANT)
    /**
      Get band1CompressorEnable
    */
    bool band1CompressorEnable() const
    {
      return mBand1CompressorEnable;
    }

    /**
      Is band1CompressorEnable Immutable
    */
    bool isBand1CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band1CompressorEnable" ) );
    }

    /**
      Get band1CompressorEnable default value
    */
    bool defaultBand1CompressorEnableValue() const
    {
        return defaultBand1CompressorEnableValue_helper();
    }

    /**
      Set band2CompressorEnable
    */
    void setBand2CompressorEnable( bool v )
    {
      if (v != mBand2CompressorEnable && !isBand2CompressorEnableImmutable()) {
        mBand2CompressorEnable = v;
        Q_EMIT band2CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band2CompressorEnable READ band2CompressorEnable WRITE setBand2CompressorEnable NOTIFY band2CompressorEnableChanged)
    Q_PROPERTY(bool isBand2CompressorEnableImmutable READ isBand2CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand2CompressorEnableValue READ defaultBand2CompressorEnableValue CONSTANT)
    /**
      Get band2CompressorEnable
    */
    bool band2CompressorEnable() const
    {
      return mBand2CompressorEnable;
    }

    /**
      Is band2CompressorEnable Immutable
    */
    bool isBand2CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band2CompressorEnable" ) );
    }

    /**
      Get band2CompressorEnable default value
    */
    bool defaultBand2CompressorEnableValue() const
    {
        return defaultBand2CompressorEnableValue_helper();
    }

    /**
      Set band3CompressorEnable
    */
    void setBand3CompressorEnable( bool v )
    {
      if (v != mBand3CompressorEnable && !isBand3CompressorEnableImmutable()) {
        mBand3CompressorEnable = v;
        Q_EMIT band3CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band3CompressorEnable READ band3CompressorEnable WRITE setBand3CompressorEnable NOTIFY band3CompressorEnableChanged)
    Q_PROPERTY(bool isBand3CompressorEnableImmutable READ isBand3CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand3CompressorEnableValue READ defaultBand3CompressorEnableValue CONSTANT)
    /**
      Get band3CompressorEnable
    */
    bool band3CompressorEnable() const
    {
      return mBand3CompressorEnable;
    }

    /**
      Is band3CompressorEnable Immutable
    */
    bool isBand3CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band3CompressorEnable" ) );
    }

    /**
      Get band3CompressorEnable default value
    */
    bool defaultBand3CompressorEnableValue() const
    {
        return defaultBand3CompressorEnableValue_helper();
    }

    /**
      Set band4CompressorEnable
    */
    void setBand4CompressorEnable( bool v )
    {
      if (v != mBand4CompressorEnable && !isBand4CompressorEnableImmutable()) {
        mBand4CompressorEnable = v;
        Q_EMIT band4CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band4CompressorEnable READ band4CompressorEnable WRITE setBand4CompressorEnable NOTIFY band4CompressorEnableChanged)
    Q_PROPERTY(bool isBand4CompressorEnableImmutable READ isBand4CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand4CompressorEnableValue READ defaultBand4CompressorEnableValue CONSTANT)
    /**
      Get band4CompressorEnable
    */
    bool band4CompressorEnable() const
    {
      return mBand4CompressorEnable;
    }

    /**
      Is band4CompressorEnable Immutable
    */
    bool isBand4CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band4CompressorEnable" ) );
    }

    /**
      Get band4CompressorEnable default value
    */
    bool defaultBand4CompressorEnableValue() const
    {
        return defaultBand4CompressorEnableValue_helper();
    }

    /**
      Set band5CompressorEnable
    */
    void setBand5CompressorEnable( bool v )
    {
      if (v != mBand5CompressorEnable && !isBand5CompressorEnableImmutable()) {
        mBand5CompressorEnable = v;
        Q_EMIT band5CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band5CompressorEnable READ band5CompressorEnable WRITE setBand5CompressorEnable NOTIFY band5CompressorEnableChanged)
    Q_PROPERTY(bool isBand5CompressorEnableImmutable READ isBand5CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand5CompressorEnableValue READ defaultBand5CompressorEnableValue CONSTANT)
    /**
      Get band5CompressorEnable
    */
    bool band5CompressorEnable() const
    {
      return mBand5CompressorEnable;
    }

    /**
      Is band5CompressorEnable Immutable
    */
    bool isBand5CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band5CompressorEnable" ) );
    }

    /**
      Get band5CompressorEnable default value
    */
    bool defaultBand5CompressorEnableValue() const
    {
        return defaultBand5CompressorEnableValue_helper();
    }

    /**
      Set band6CompressorEnable
    */
    void setBand6CompressorEnable( bool v )
    {
      if (v != mBand6CompressorEnable && !isBand6CompressorEnableImmutable()) {
        mBand6CompressorEnable = v;
        Q_EMIT band6CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band6CompressorEnable READ band6CompressorEnable WRITE setBand6CompressorEnable NOTIFY band6CompressorEnableChanged)
    Q_PROPERTY(bool isBand6CompressorEnableImmutable READ isBand6CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand6CompressorEnableValue READ defaultBand6CompressorEnableValue CONSTANT)
    /**
      Get band6CompressorEnable
    */
    bool band6CompressorEnable() const
    {
      return mBand6CompressorEnable;
    }

    /**
      Is band6CompressorEnable Immutable
    */
    bool isBand6CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band6CompressorEnable" ) );
    }

    /**
      Get band6CompressorEnable default value
    */
    bool defaultBand6CompressorEnableValue() const
    {
        return defaultBand6CompressorEnableValue_helper();
    }

    /**
      Set band7CompressorEnable
    */
    void setBand7CompressorEnable( bool v )
    {
      if (v != mBand7CompressorEnable && !isBand7CompressorEnableImmutable()) {
        mBand7CompressorEnable = v;
        Q_EMIT band7CompressorEnableChanged();
      }
    }

    Q_PROPERTY(bool band7CompressorEnable READ band7CompressorEnable WRITE setBand7CompressorEnable NOTIFY band7CompressorEnableChanged)
    Q_PROPERTY(bool isBand7CompressorEnableImmutable READ isBand7CompressorEnableImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand7CompressorEnableValue READ defaultBand7CompressorEnableValue CONSTANT)
    /**
      Get band7CompressorEnable
    */
    bool band7CompressorEnable() const
    {
      return mBand7CompressorEnable;
    }

    /**
      Is band7CompressorEnable Immutable
    */
    bool isBand7CompressorEnableImmutable() const
    {
      return isImmutable( QStringLiteral( "band7CompressorEnable" ) );
    }

    /**
      Get band7CompressorEnable default value
    */
    bool defaultBand7CompressorEnableValue() const
    {
        return defaultBand7CompressorEnableValue_helper();
    }

    /**
      Set band0Solo
    */
    void setBand0Solo( bool v )
    {
      if (v != mBand0Solo && !isBand0SoloImmutable()) {
        mBand0Solo = v;
        Q_EMIT band0SoloChanged();
      }
    }

    Q_PROPERTY(bool band0Solo READ band0Solo WRITE setBand0Solo NOTIFY band0SoloChanged)
    Q_PROPERTY(bool isBand0SoloImmutable READ isBand0SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand0SoloValue READ defaultBand0SoloValue CONSTANT)
    /**
      Get band0Solo
    */
    bool band0Solo() const
    {
      return mBand0Solo;
    }

    /**
      Is band0Solo Immutable
    */
    bool isBand0SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band0Solo" ) );
    }

    /**
      Get band0Solo default value
    */
    bool defaultBand0SoloValue() const
    {
        return defaultBand0SoloValue_helper();
    }

    /**
      Set band1Solo
    */
    void setBand1Solo( bool v )
    {
      if (v != mBand1Solo && !isBand1SoloImmutable()) {
        mBand1Solo = v;
        Q_EMIT band1SoloChanged();
      }
    }

    Q_PROPERTY(bool band1Solo READ band1Solo WRITE setBand1Solo NOTIFY band1SoloChanged)
    Q_PROPERTY(bool isBand1SoloImmutable READ isBand1SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand1SoloValue READ defaultBand1SoloValue CONSTANT)
    /**
      Get band1Solo
    */
    bool band1Solo() const
    {
      return mBand1Solo;
    }

    /**
      Is band1Solo Immutable
    */
    bool isBand1SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band1Solo" ) );
    }

    /**
      Get band1Solo default value
    */
    bool defaultBand1SoloValue() const
    {
        return defaultBand1SoloValue_helper();
    }

    /**
      Set band2Solo
    */
    void setBand2Solo( bool v )
    {
      if (v != mBand2Solo && !isBand2SoloImmutable()) {
        mBand2Solo = v;
        Q_EMIT band2SoloChanged();
      }
    }

    Q_PROPERTY(bool band2Solo READ band2Solo WRITE setBand2Solo NOTIFY band2SoloChanged)
    Q_PROPERTY(bool isBand2SoloImmutable READ isBand2SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand2SoloValue READ defaultBand2SoloValue CONSTANT)
    /**
      Get band2Solo
    */
    bool band2Solo() const
    {
      return mBand2Solo;
    }

    /**
      Is band2Solo Immutable
    */
    bool isBand2SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band2Solo" ) );
    }

    /**
      Get band2Solo default value
    */
    bool defaultBand2SoloValue() const
    {
        return defaultBand2SoloValue_helper();
    }

    /**
      Set band3Solo
    */
    void setBand3Solo( bool v )
    {
      if (v != mBand3Solo && !isBand3SoloImmutable()) {
        mBand3Solo = v;
        Q_EMIT band3SoloChanged();
      }
    }

    Q_PROPERTY(bool band3Solo READ band3Solo WRITE setBand3Solo NOTIFY band3SoloChanged)
    Q_PROPERTY(bool isBand3SoloImmutable READ isBand3SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand3SoloValue READ defaultBand3SoloValue CONSTANT)
    /**
      Get band3Solo
    */
    bool band3Solo() const
    {
      return mBand3Solo;
    }

    /**
      Is band3Solo Immutable
    */
    bool isBand3SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band3Solo" ) );
    }

    /**
      Get band3Solo default value
    */
    bool defaultBand3SoloValue() const
    {
        return defaultBand3SoloValue_helper();
    }

    /**
      Set band4Solo
    */
    void setBand4Solo( bool v )
    {
      if (v != mBand4Solo && !isBand4SoloImmutable()) {
        mBand4Solo = v;
        Q_EMIT band4SoloChanged();
      }
    }

    Q_PROPERTY(bool band4Solo READ band4Solo WRITE setBand4Solo NOTIFY band4SoloChanged)
    Q_PROPERTY(bool isBand4SoloImmutable READ isBand4SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand4SoloValue READ defaultBand4SoloValue CONSTANT)
    /**
      Get band4Solo
    */
    bool band4Solo() const
    {
      return mBand4Solo;
    }

    /**
      Is band4Solo Immutable
    */
    bool isBand4SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band4Solo" ) );
    }

    /**
      Get band4Solo default value
    */
    bool defaultBand4SoloValue() const
    {
        return defaultBand4SoloValue_helper();
    }

    /**
      Set band5Solo
    */
    void setBand5Solo( bool v )
    {
      if (v != mBand5Solo && !isBand5SoloImmutable()) {
        mBand5Solo = v;
        Q_EMIT band5SoloChanged();
      }
    }

    Q_PROPERTY(bool band5Solo READ band5Solo WRITE setBand5Solo NOTIFY band5SoloChanged)
    Q_PROPERTY(bool isBand5SoloImmutable READ isBand5SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand5SoloValue READ defaultBand5SoloValue CONSTANT)
    /**
      Get band5Solo
    */
    bool band5Solo() const
    {
      return mBand5Solo;
    }

    /**
      Is band5Solo Immutable
    */
    bool isBand5SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band5Solo" ) );
    }

    /**
      Get band5Solo default value
    */
    bool defaultBand5SoloValue() const
    {
        return defaultBand5SoloValue_helper();
    }

    /**
      Set band6Solo
    */
    void setBand6Solo( bool v )
    {
      if (v != mBand6Solo && !isBand6SoloImmutable()) {
        mBand6Solo = v;
        Q_EMIT band6SoloChanged();
      }
    }

    Q_PROPERTY(bool band6Solo READ band6Solo WRITE setBand6Solo NOTIFY band6SoloChanged)
    Q_PROPERTY(bool isBand6SoloImmutable READ isBand6SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand6SoloValue READ defaultBand6SoloValue CONSTANT)
    /**
      Get band6Solo
    */
    bool band6Solo() const
    {
      return mBand6Solo;
    }

    /**
      Is band6Solo Immutable
    */
    bool isBand6SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band6Solo" ) );
    }

    /**
      Get band6Solo default value
    */
    bool defaultBand6SoloValue() const
    {
        return defaultBand6SoloValue_helper();
    }

    /**
      Set band7Solo
    */
    void setBand7Solo( bool v )
    {
      if (v != mBand7Solo && !isBand7SoloImmutable()) {
        mBand7Solo = v;
        Q_EMIT band7SoloChanged();
      }
    }

    Q_PROPERTY(bool band7Solo READ band7Solo WRITE setBand7Solo NOTIFY band7SoloChanged)
    Q_PROPERTY(bool isBand7SoloImmutable READ isBand7SoloImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand7SoloValue READ defaultBand7SoloValue CONSTANT)
    /**
      Get band7Solo
    */
    bool band7Solo() const
    {
      return mBand7Solo;
    }

    /**
      Is band7Solo Immutable
    */
    bool isBand7SoloImmutable() const
    {
      return isImmutable( QStringLiteral( "band7Solo" ) );
    }

    /**
      Get band7Solo default value
    */
    bool defaultBand7SoloValue() const
    {
        return defaultBand7SoloValue_helper();
    }

    /**
      Set band0Mute
    */
    void setBand0Mute( bool v )
    {
      if (v != mBand0Mute && !isBand0MuteImmutable()) {
        mBand0Mute = v;
        Q_EMIT band0MuteChanged();
      }
    }

    Q_PROPERTY(bool band0Mute READ band0Mute WRITE setBand0Mute NOTIFY band0MuteChanged)
    Q_PROPERTY(bool isBand0MuteImmutable READ isBand0MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand0MuteValue READ defaultBand0MuteValue CONSTANT)
    /**
      Get band0Mute
    */
    bool band0Mute() const
    {
      return mBand0Mute;
    }

    /**
      Is band0Mute Immutable
    */
    bool isBand0MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band0Mute" ) );
    }

    /**
      Get band0Mute default value
    */
    bool defaultBand0MuteValue() const
    {
        return defaultBand0MuteValue_helper();
    }

    /**
      Set band1Mute
    */
    void setBand1Mute( bool v )
    {
      if (v != mBand1Mute && !isBand1MuteImmutable()) {
        mBand1Mute = v;
        Q_EMIT band1MuteChanged();
      }
    }

    Q_PROPERTY(bool band1Mute READ band1Mute WRITE setBand1Mute NOTIFY band1MuteChanged)
    Q_PROPERTY(bool isBand1MuteImmutable READ isBand1MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand1MuteValue READ defaultBand1MuteValue CONSTANT)
    /**
      Get band1Mute
    */
    bool band1Mute() const
    {
      return mBand1Mute;
    }

    /**
      Is band1Mute Immutable
    */
    bool isBand1MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band1Mute" ) );
    }

    /**
      Get band1Mute default value
    */
    bool defaultBand1MuteValue() const
    {
        return defaultBand1MuteValue_helper();
    }

    /**
      Set band2Mute
    */
    void setBand2Mute( bool v )
    {
      if (v != mBand2Mute && !isBand2MuteImmutable()) {
        mBand2Mute = v;
        Q_EMIT band2MuteChanged();
      }
    }

    Q_PROPERTY(bool band2Mute READ band2Mute WRITE setBand2Mute NOTIFY band2MuteChanged)
    Q_PROPERTY(bool isBand2MuteImmutable READ isBand2MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand2MuteValue READ defaultBand2MuteValue CONSTANT)
    /**
      Get band2Mute
    */
    bool band2Mute() const
    {
      return mBand2Mute;
    }

    /**
      Is band2Mute Immutable
    */
    bool isBand2MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band2Mute" ) );
    }

    /**
      Get band2Mute default value
    */
    bool defaultBand2MuteValue() const
    {
        return defaultBand2MuteValue_helper();
    }

    /**
      Set band3Mute
    */
    void setBand3Mute( bool v )
    {
      if (v != mBand3Mute && !isBand3MuteImmutable()) {
        mBand3Mute = v;
        Q_EMIT band3MuteChanged();
      }
    }

    Q_PROPERTY(bool band3Mute READ band3Mute WRITE setBand3Mute NOTIFY band3MuteChanged)
    Q_PROPERTY(bool isBand3MuteImmutable READ isBand3MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand3MuteValue READ defaultBand3MuteValue CONSTANT)
    /**
      Get band3Mute
    */
    bool band3Mute() const
    {
      return mBand3Mute;
    }

    /**
      Is band3Mute Immutable
    */
    bool isBand3MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band3Mute" ) );
    }

    /**
      Get band3Mute default value
    */
    bool defaultBand3MuteValue() const
    {
        return defaultBand3MuteValue_helper();
    }

    /**
      Set band4Mute
    */
    void setBand4Mute( bool v )
    {
      if (v != mBand4Mute && !isBand4MuteImmutable()) {
        mBand4Mute = v;
        Q_EMIT band4MuteChanged();
      }
    }

    Q_PROPERTY(bool band4Mute READ band4Mute WRITE setBand4Mute NOTIFY band4MuteChanged)
    Q_PROPERTY(bool isBand4MuteImmutable READ isBand4MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand4MuteValue READ defaultBand4MuteValue CONSTANT)
    /**
      Get band4Mute
    */
    bool band4Mute() const
    {
      return mBand4Mute;
    }

    /**
      Is band4Mute Immutable
    */
    bool isBand4MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band4Mute" ) );
    }

    /**
      Get band4Mute default value
    */
    bool defaultBand4MuteValue() const
    {
        return defaultBand4MuteValue_helper();
    }

    /**
      Set band5Mute
    */
    void setBand5Mute( bool v )
    {
      if (v != mBand5Mute && !isBand5MuteImmutable()) {
        mBand5Mute = v;
        Q_EMIT band5MuteChanged();
      }
    }

    Q_PROPERTY(bool band5Mute READ band5Mute WRITE setBand5Mute NOTIFY band5MuteChanged)
    Q_PROPERTY(bool isBand5MuteImmutable READ isBand5MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand5MuteValue READ defaultBand5MuteValue CONSTANT)
    /**
      Get band5Mute
    */
    bool band5Mute() const
    {
      return mBand5Mute;
    }

    /**
      Is band5Mute Immutable
    */
    bool isBand5MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band5Mute" ) );
    }

    /**
      Get band5Mute default value
    */
    bool defaultBand5MuteValue() const
    {
        return defaultBand5MuteValue_helper();
    }

    /**
      Set band6Mute
    */
    void setBand6Mute( bool v )
    {
      if (v != mBand6Mute && !isBand6MuteImmutable()) {
        mBand6Mute = v;
        Q_EMIT band6MuteChanged();
      }
    }

    Q_PROPERTY(bool band6Mute READ band6Mute WRITE setBand6Mute NOTIFY band6MuteChanged)
    Q_PROPERTY(bool isBand6MuteImmutable READ isBand6MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand6MuteValue READ defaultBand6MuteValue CONSTANT)
    /**
      Get band6Mute
    */
    bool band6Mute() const
    {
      return mBand6Mute;
    }

    /**
      Is band6Mute Immutable
    */
    bool isBand6MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band6Mute" ) );
    }

    /**
      Get band6Mute default value
    */
    bool defaultBand6MuteValue() const
    {
        return defaultBand6MuteValue_helper();
    }

    /**
      Set band7Mute
    */
    void setBand7Mute( bool v )
    {
      if (v != mBand7Mute && !isBand7MuteImmutable()) {
        mBand7Mute = v;
        Q_EMIT band7MuteChanged();
      }
    }

    Q_PROPERTY(bool band7Mute READ band7Mute WRITE setBand7Mute NOTIFY band7MuteChanged)
    Q_PROPERTY(bool isBand7MuteImmutable READ isBand7MuteImmutable CONSTANT)
    Q_PROPERTY(bool defaultBand7MuteValue READ defaultBand7MuteValue CONSTANT)
    /**
      Get band7Mute
    */
    bool band7Mute() const
    {
      return mBand7Mute;
    }

    /**
      Is band7Mute Immutable
    */
    bool isBand7MuteImmutable() const
    {
      return isImmutable( QStringLiteral( "band7Mute" ) );
    }

    /**
      Get band7Mute default value
    */
    bool defaultBand7MuteValue() const
    {
        return defaultBand7MuteValue_helper();
    }

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

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

      if (v != mBand0AttackThreshold && !isBand0AttackThresholdImmutable()) {
        mBand0AttackThreshold = v;
        Q_EMIT band0AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band0AttackThreshold READ band0AttackThreshold WRITE setBand0AttackThreshold NOTIFY band0AttackThresholdChanged)
    Q_PROPERTY(bool isBand0AttackThresholdImmutable READ isBand0AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0AttackThresholdValue READ defaultBand0AttackThresholdValue CONSTANT)
    /**
      Get band0AttackThreshold
    */
    double band0AttackThreshold() const
    {
      return mBand0AttackThreshold;
    }

    /**
      Is band0AttackThreshold Immutable
    */
    bool isBand0AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band0AttackThreshold" ) );
    }

    /**
      Get band0AttackThreshold default value
    */
    double defaultBand0AttackThresholdValue() const
    {
        return defaultBand0AttackThresholdValue_helper();
    }

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

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

      if (v != mBand1AttackThreshold && !isBand1AttackThresholdImmutable()) {
        mBand1AttackThreshold = v;
        Q_EMIT band1AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band1AttackThreshold READ band1AttackThreshold WRITE setBand1AttackThreshold NOTIFY band1AttackThresholdChanged)
    Q_PROPERTY(bool isBand1AttackThresholdImmutable READ isBand1AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1AttackThresholdValue READ defaultBand1AttackThresholdValue CONSTANT)
    /**
      Get band1AttackThreshold
    */
    double band1AttackThreshold() const
    {
      return mBand1AttackThreshold;
    }

    /**
      Is band1AttackThreshold Immutable
    */
    bool isBand1AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band1AttackThreshold" ) );
    }

    /**
      Get band1AttackThreshold default value
    */
    double defaultBand1AttackThresholdValue() const
    {
        return defaultBand1AttackThresholdValue_helper();
    }

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

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

      if (v != mBand2AttackThreshold && !isBand2AttackThresholdImmutable()) {
        mBand2AttackThreshold = v;
        Q_EMIT band2AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band2AttackThreshold READ band2AttackThreshold WRITE setBand2AttackThreshold NOTIFY band2AttackThresholdChanged)
    Q_PROPERTY(bool isBand2AttackThresholdImmutable READ isBand2AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2AttackThresholdValue READ defaultBand2AttackThresholdValue CONSTANT)
    /**
      Get band2AttackThreshold
    */
    double band2AttackThreshold() const
    {
      return mBand2AttackThreshold;
    }

    /**
      Is band2AttackThreshold Immutable
    */
    bool isBand2AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band2AttackThreshold" ) );
    }

    /**
      Get band2AttackThreshold default value
    */
    double defaultBand2AttackThresholdValue() const
    {
        return defaultBand2AttackThresholdValue_helper();
    }

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

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

      if (v != mBand3AttackThreshold && !isBand3AttackThresholdImmutable()) {
        mBand3AttackThreshold = v;
        Q_EMIT band3AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band3AttackThreshold READ band3AttackThreshold WRITE setBand3AttackThreshold NOTIFY band3AttackThresholdChanged)
    Q_PROPERTY(bool isBand3AttackThresholdImmutable READ isBand3AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3AttackThresholdValue READ defaultBand3AttackThresholdValue CONSTANT)
    /**
      Get band3AttackThreshold
    */
    double band3AttackThreshold() const
    {
      return mBand3AttackThreshold;
    }

    /**
      Is band3AttackThreshold Immutable
    */
    bool isBand3AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band3AttackThreshold" ) );
    }

    /**
      Get band3AttackThreshold default value
    */
    double defaultBand3AttackThresholdValue() const
    {
        return defaultBand3AttackThresholdValue_helper();
    }

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

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

      if (v != mBand4AttackThreshold && !isBand4AttackThresholdImmutable()) {
        mBand4AttackThreshold = v;
        Q_EMIT band4AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band4AttackThreshold READ band4AttackThreshold WRITE setBand4AttackThreshold NOTIFY band4AttackThresholdChanged)
    Q_PROPERTY(bool isBand4AttackThresholdImmutable READ isBand4AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4AttackThresholdValue READ defaultBand4AttackThresholdValue CONSTANT)
    /**
      Get band4AttackThreshold
    */
    double band4AttackThreshold() const
    {
      return mBand4AttackThreshold;
    }

    /**
      Is band4AttackThreshold Immutable
    */
    bool isBand4AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band4AttackThreshold" ) );
    }

    /**
      Get band4AttackThreshold default value
    */
    double defaultBand4AttackThresholdValue() const
    {
        return defaultBand4AttackThresholdValue_helper();
    }

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

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

      if (v != mBand5AttackThreshold && !isBand5AttackThresholdImmutable()) {
        mBand5AttackThreshold = v;
        Q_EMIT band5AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band5AttackThreshold READ band5AttackThreshold WRITE setBand5AttackThreshold NOTIFY band5AttackThresholdChanged)
    Q_PROPERTY(bool isBand5AttackThresholdImmutable READ isBand5AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5AttackThresholdValue READ defaultBand5AttackThresholdValue CONSTANT)
    /**
      Get band5AttackThreshold
    */
    double band5AttackThreshold() const
    {
      return mBand5AttackThreshold;
    }

    /**
      Is band5AttackThreshold Immutable
    */
    bool isBand5AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band5AttackThreshold" ) );
    }

    /**
      Get band5AttackThreshold default value
    */
    double defaultBand5AttackThresholdValue() const
    {
        return defaultBand5AttackThresholdValue_helper();
    }

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

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

      if (v != mBand6AttackThreshold && !isBand6AttackThresholdImmutable()) {
        mBand6AttackThreshold = v;
        Q_EMIT band6AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band6AttackThreshold READ band6AttackThreshold WRITE setBand6AttackThreshold NOTIFY band6AttackThresholdChanged)
    Q_PROPERTY(bool isBand6AttackThresholdImmutable READ isBand6AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6AttackThresholdValue READ defaultBand6AttackThresholdValue CONSTANT)
    /**
      Get band6AttackThreshold
    */
    double band6AttackThreshold() const
    {
      return mBand6AttackThreshold;
    }

    /**
      Is band6AttackThreshold Immutable
    */
    bool isBand6AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band6AttackThreshold" ) );
    }

    /**
      Get band6AttackThreshold default value
    */
    double defaultBand6AttackThresholdValue() const
    {
        return defaultBand6AttackThresholdValue_helper();
    }

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

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

      if (v != mBand7AttackThreshold && !isBand7AttackThresholdImmutable()) {
        mBand7AttackThreshold = v;
        Q_EMIT band7AttackThresholdChanged();
      }
    }

    Q_PROPERTY(double band7AttackThreshold READ band7AttackThreshold WRITE setBand7AttackThreshold NOTIFY band7AttackThresholdChanged)
    Q_PROPERTY(bool isBand7AttackThresholdImmutable READ isBand7AttackThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7AttackThresholdValue READ defaultBand7AttackThresholdValue CONSTANT)
    /**
      Get band7AttackThreshold
    */
    double band7AttackThreshold() const
    {
      return mBand7AttackThreshold;
    }

    /**
      Is band7AttackThreshold Immutable
    */
    bool isBand7AttackThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band7AttackThreshold" ) );
    }

    /**
      Get band7AttackThreshold default value
    */
    double defaultBand7AttackThresholdValue() const
    {
        return defaultBand7AttackThresholdValue_helper();
    }

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

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

      if (v != mBand0AttackTime && !isBand0AttackTimeImmutable()) {
        mBand0AttackTime = v;
        Q_EMIT band0AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band0AttackTime READ band0AttackTime WRITE setBand0AttackTime NOTIFY band0AttackTimeChanged)
    Q_PROPERTY(bool isBand0AttackTimeImmutable READ isBand0AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0AttackTimeValue READ defaultBand0AttackTimeValue CONSTANT)
    /**
      Get band0AttackTime
    */
    double band0AttackTime() const
    {
      return mBand0AttackTime;
    }

    /**
      Is band0AttackTime Immutable
    */
    bool isBand0AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band0AttackTime" ) );
    }

    /**
      Get band0AttackTime default value
    */
    double defaultBand0AttackTimeValue() const
    {
        return defaultBand0AttackTimeValue_helper();
    }

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

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

      if (v != mBand1AttackTime && !isBand1AttackTimeImmutable()) {
        mBand1AttackTime = v;
        Q_EMIT band1AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band1AttackTime READ band1AttackTime WRITE setBand1AttackTime NOTIFY band1AttackTimeChanged)
    Q_PROPERTY(bool isBand1AttackTimeImmutable READ isBand1AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1AttackTimeValue READ defaultBand1AttackTimeValue CONSTANT)
    /**
      Get band1AttackTime
    */
    double band1AttackTime() const
    {
      return mBand1AttackTime;
    }

    /**
      Is band1AttackTime Immutable
    */
    bool isBand1AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band1AttackTime" ) );
    }

    /**
      Get band1AttackTime default value
    */
    double defaultBand1AttackTimeValue() const
    {
        return defaultBand1AttackTimeValue_helper();
    }

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

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

      if (v != mBand2AttackTime && !isBand2AttackTimeImmutable()) {
        mBand2AttackTime = v;
        Q_EMIT band2AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band2AttackTime READ band2AttackTime WRITE setBand2AttackTime NOTIFY band2AttackTimeChanged)
    Q_PROPERTY(bool isBand2AttackTimeImmutable READ isBand2AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2AttackTimeValue READ defaultBand2AttackTimeValue CONSTANT)
    /**
      Get band2AttackTime
    */
    double band2AttackTime() const
    {
      return mBand2AttackTime;
    }

    /**
      Is band2AttackTime Immutable
    */
    bool isBand2AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band2AttackTime" ) );
    }

    /**
      Get band2AttackTime default value
    */
    double defaultBand2AttackTimeValue() const
    {
        return defaultBand2AttackTimeValue_helper();
    }

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

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

      if (v != mBand3AttackTime && !isBand3AttackTimeImmutable()) {
        mBand3AttackTime = v;
        Q_EMIT band3AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band3AttackTime READ band3AttackTime WRITE setBand3AttackTime NOTIFY band3AttackTimeChanged)
    Q_PROPERTY(bool isBand3AttackTimeImmutable READ isBand3AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3AttackTimeValue READ defaultBand3AttackTimeValue CONSTANT)
    /**
      Get band3AttackTime
    */
    double band3AttackTime() const
    {
      return mBand3AttackTime;
    }

    /**
      Is band3AttackTime Immutable
    */
    bool isBand3AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band3AttackTime" ) );
    }

    /**
      Get band3AttackTime default value
    */
    double defaultBand3AttackTimeValue() const
    {
        return defaultBand3AttackTimeValue_helper();
    }

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

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

      if (v != mBand4AttackTime && !isBand4AttackTimeImmutable()) {
        mBand4AttackTime = v;
        Q_EMIT band4AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band4AttackTime READ band4AttackTime WRITE setBand4AttackTime NOTIFY band4AttackTimeChanged)
    Q_PROPERTY(bool isBand4AttackTimeImmutable READ isBand4AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4AttackTimeValue READ defaultBand4AttackTimeValue CONSTANT)
    /**
      Get band4AttackTime
    */
    double band4AttackTime() const
    {
      return mBand4AttackTime;
    }

    /**
      Is band4AttackTime Immutable
    */
    bool isBand4AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band4AttackTime" ) );
    }

    /**
      Get band4AttackTime default value
    */
    double defaultBand4AttackTimeValue() const
    {
        return defaultBand4AttackTimeValue_helper();
    }

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

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

      if (v != mBand5AttackTime && !isBand5AttackTimeImmutable()) {
        mBand5AttackTime = v;
        Q_EMIT band5AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band5AttackTime READ band5AttackTime WRITE setBand5AttackTime NOTIFY band5AttackTimeChanged)
    Q_PROPERTY(bool isBand5AttackTimeImmutable READ isBand5AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5AttackTimeValue READ defaultBand5AttackTimeValue CONSTANT)
    /**
      Get band5AttackTime
    */
    double band5AttackTime() const
    {
      return mBand5AttackTime;
    }

    /**
      Is band5AttackTime Immutable
    */
    bool isBand5AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band5AttackTime" ) );
    }

    /**
      Get band5AttackTime default value
    */
    double defaultBand5AttackTimeValue() const
    {
        return defaultBand5AttackTimeValue_helper();
    }

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

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

      if (v != mBand6AttackTime && !isBand6AttackTimeImmutable()) {
        mBand6AttackTime = v;
        Q_EMIT band6AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band6AttackTime READ band6AttackTime WRITE setBand6AttackTime NOTIFY band6AttackTimeChanged)
    Q_PROPERTY(bool isBand6AttackTimeImmutable READ isBand6AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6AttackTimeValue READ defaultBand6AttackTimeValue CONSTANT)
    /**
      Get band6AttackTime
    */
    double band6AttackTime() const
    {
      return mBand6AttackTime;
    }

    /**
      Is band6AttackTime Immutable
    */
    bool isBand6AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band6AttackTime" ) );
    }

    /**
      Get band6AttackTime default value
    */
    double defaultBand6AttackTimeValue() const
    {
        return defaultBand6AttackTimeValue_helper();
    }

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

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

      if (v != mBand7AttackTime && !isBand7AttackTimeImmutable()) {
        mBand7AttackTime = v;
        Q_EMIT band7AttackTimeChanged();
      }
    }

    Q_PROPERTY(double band7AttackTime READ band7AttackTime WRITE setBand7AttackTime NOTIFY band7AttackTimeChanged)
    Q_PROPERTY(bool isBand7AttackTimeImmutable READ isBand7AttackTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7AttackTimeValue READ defaultBand7AttackTimeValue CONSTANT)
    /**
      Get band7AttackTime
    */
    double band7AttackTime() const
    {
      return mBand7AttackTime;
    }

    /**
      Is band7AttackTime Immutable
    */
    bool isBand7AttackTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band7AttackTime" ) );
    }

    /**
      Get band7AttackTime default value
    */
    double defaultBand7AttackTimeValue() const
    {
        return defaultBand7AttackTimeValue_helper();
    }

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

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

      if (v != mBand0ReleaseThreshold && !isBand0ReleaseThresholdImmutable()) {
        mBand0ReleaseThreshold = v;
        Q_EMIT band0ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band0ReleaseThreshold READ band0ReleaseThreshold WRITE setBand0ReleaseThreshold NOTIFY band0ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand0ReleaseThresholdImmutable READ isBand0ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0ReleaseThresholdValue READ defaultBand0ReleaseThresholdValue CONSTANT)
    /**
      Get band0ReleaseThreshold
    */
    double band0ReleaseThreshold() const
    {
      return mBand0ReleaseThreshold;
    }

    /**
      Is band0ReleaseThreshold Immutable
    */
    bool isBand0ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band0ReleaseThreshold" ) );
    }

    /**
      Get band0ReleaseThreshold default value
    */
    double defaultBand0ReleaseThresholdValue() const
    {
        return defaultBand0ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand1ReleaseThreshold && !isBand1ReleaseThresholdImmutable()) {
        mBand1ReleaseThreshold = v;
        Q_EMIT band1ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band1ReleaseThreshold READ band1ReleaseThreshold WRITE setBand1ReleaseThreshold NOTIFY band1ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand1ReleaseThresholdImmutable READ isBand1ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1ReleaseThresholdValue READ defaultBand1ReleaseThresholdValue CONSTANT)
    /**
      Get band1ReleaseThreshold
    */
    double band1ReleaseThreshold() const
    {
      return mBand1ReleaseThreshold;
    }

    /**
      Is band1ReleaseThreshold Immutable
    */
    bool isBand1ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band1ReleaseThreshold" ) );
    }

    /**
      Get band1ReleaseThreshold default value
    */
    double defaultBand1ReleaseThresholdValue() const
    {
        return defaultBand1ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand2ReleaseThreshold && !isBand2ReleaseThresholdImmutable()) {
        mBand2ReleaseThreshold = v;
        Q_EMIT band2ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band2ReleaseThreshold READ band2ReleaseThreshold WRITE setBand2ReleaseThreshold NOTIFY band2ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand2ReleaseThresholdImmutable READ isBand2ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2ReleaseThresholdValue READ defaultBand2ReleaseThresholdValue CONSTANT)
    /**
      Get band2ReleaseThreshold
    */
    double band2ReleaseThreshold() const
    {
      return mBand2ReleaseThreshold;
    }

    /**
      Is band2ReleaseThreshold Immutable
    */
    bool isBand2ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band2ReleaseThreshold" ) );
    }

    /**
      Get band2ReleaseThreshold default value
    */
    double defaultBand2ReleaseThresholdValue() const
    {
        return defaultBand2ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand3ReleaseThreshold && !isBand3ReleaseThresholdImmutable()) {
        mBand3ReleaseThreshold = v;
        Q_EMIT band3ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band3ReleaseThreshold READ band3ReleaseThreshold WRITE setBand3ReleaseThreshold NOTIFY band3ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand3ReleaseThresholdImmutable READ isBand3ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3ReleaseThresholdValue READ defaultBand3ReleaseThresholdValue CONSTANT)
    /**
      Get band3ReleaseThreshold
    */
    double band3ReleaseThreshold() const
    {
      return mBand3ReleaseThreshold;
    }

    /**
      Is band3ReleaseThreshold Immutable
    */
    bool isBand3ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band3ReleaseThreshold" ) );
    }

    /**
      Get band3ReleaseThreshold default value
    */
    double defaultBand3ReleaseThresholdValue() const
    {
        return defaultBand3ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand4ReleaseThreshold && !isBand4ReleaseThresholdImmutable()) {
        mBand4ReleaseThreshold = v;
        Q_EMIT band4ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band4ReleaseThreshold READ band4ReleaseThreshold WRITE setBand4ReleaseThreshold NOTIFY band4ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand4ReleaseThresholdImmutable READ isBand4ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4ReleaseThresholdValue READ defaultBand4ReleaseThresholdValue CONSTANT)
    /**
      Get band4ReleaseThreshold
    */
    double band4ReleaseThreshold() const
    {
      return mBand4ReleaseThreshold;
    }

    /**
      Is band4ReleaseThreshold Immutable
    */
    bool isBand4ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band4ReleaseThreshold" ) );
    }

    /**
      Get band4ReleaseThreshold default value
    */
    double defaultBand4ReleaseThresholdValue() const
    {
        return defaultBand4ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand5ReleaseThreshold && !isBand5ReleaseThresholdImmutable()) {
        mBand5ReleaseThreshold = v;
        Q_EMIT band5ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band5ReleaseThreshold READ band5ReleaseThreshold WRITE setBand5ReleaseThreshold NOTIFY band5ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand5ReleaseThresholdImmutable READ isBand5ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5ReleaseThresholdValue READ defaultBand5ReleaseThresholdValue CONSTANT)
    /**
      Get band5ReleaseThreshold
    */
    double band5ReleaseThreshold() const
    {
      return mBand5ReleaseThreshold;
    }

    /**
      Is band5ReleaseThreshold Immutable
    */
    bool isBand5ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band5ReleaseThreshold" ) );
    }

    /**
      Get band5ReleaseThreshold default value
    */
    double defaultBand5ReleaseThresholdValue() const
    {
        return defaultBand5ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand6ReleaseThreshold && !isBand6ReleaseThresholdImmutable()) {
        mBand6ReleaseThreshold = v;
        Q_EMIT band6ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band6ReleaseThreshold READ band6ReleaseThreshold WRITE setBand6ReleaseThreshold NOTIFY band6ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand6ReleaseThresholdImmutable READ isBand6ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6ReleaseThresholdValue READ defaultBand6ReleaseThresholdValue CONSTANT)
    /**
      Get band6ReleaseThreshold
    */
    double band6ReleaseThreshold() const
    {
      return mBand6ReleaseThreshold;
    }

    /**
      Is band6ReleaseThreshold Immutable
    */
    bool isBand6ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band6ReleaseThreshold" ) );
    }

    /**
      Get band6ReleaseThreshold default value
    */
    double defaultBand6ReleaseThresholdValue() const
    {
        return defaultBand6ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand7ReleaseThreshold && !isBand7ReleaseThresholdImmutable()) {
        mBand7ReleaseThreshold = v;
        Q_EMIT band7ReleaseThresholdChanged();
      }
    }

    Q_PROPERTY(double band7ReleaseThreshold READ band7ReleaseThreshold WRITE setBand7ReleaseThreshold NOTIFY band7ReleaseThresholdChanged)
    Q_PROPERTY(bool isBand7ReleaseThresholdImmutable READ isBand7ReleaseThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7ReleaseThresholdValue READ defaultBand7ReleaseThresholdValue CONSTANT)
    /**
      Get band7ReleaseThreshold
    */
    double band7ReleaseThreshold() const
    {
      return mBand7ReleaseThreshold;
    }

    /**
      Is band7ReleaseThreshold Immutable
    */
    bool isBand7ReleaseThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band7ReleaseThreshold" ) );
    }

    /**
      Get band7ReleaseThreshold default value
    */
    double defaultBand7ReleaseThresholdValue() const
    {
        return defaultBand7ReleaseThresholdValue_helper();
    }

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

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

      if (v != mBand0ReleaseTime && !isBand0ReleaseTimeImmutable()) {
        mBand0ReleaseTime = v;
        Q_EMIT band0ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band0ReleaseTime READ band0ReleaseTime WRITE setBand0ReleaseTime NOTIFY band0ReleaseTimeChanged)
    Q_PROPERTY(bool isBand0ReleaseTimeImmutable READ isBand0ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0ReleaseTimeValue READ defaultBand0ReleaseTimeValue CONSTANT)
    /**
      Get band0ReleaseTime
    */
    double band0ReleaseTime() const
    {
      return mBand0ReleaseTime;
    }

    /**
      Is band0ReleaseTime Immutable
    */
    bool isBand0ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band0ReleaseTime" ) );
    }

    /**
      Get band0ReleaseTime default value
    */
    double defaultBand0ReleaseTimeValue() const
    {
        return defaultBand0ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand1ReleaseTime && !isBand1ReleaseTimeImmutable()) {
        mBand1ReleaseTime = v;
        Q_EMIT band1ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band1ReleaseTime READ band1ReleaseTime WRITE setBand1ReleaseTime NOTIFY band1ReleaseTimeChanged)
    Q_PROPERTY(bool isBand1ReleaseTimeImmutable READ isBand1ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1ReleaseTimeValue READ defaultBand1ReleaseTimeValue CONSTANT)
    /**
      Get band1ReleaseTime
    */
    double band1ReleaseTime() const
    {
      return mBand1ReleaseTime;
    }

    /**
      Is band1ReleaseTime Immutable
    */
    bool isBand1ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band1ReleaseTime" ) );
    }

    /**
      Get band1ReleaseTime default value
    */
    double defaultBand1ReleaseTimeValue() const
    {
        return defaultBand1ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand2ReleaseTime && !isBand2ReleaseTimeImmutable()) {
        mBand2ReleaseTime = v;
        Q_EMIT band2ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band2ReleaseTime READ band2ReleaseTime WRITE setBand2ReleaseTime NOTIFY band2ReleaseTimeChanged)
    Q_PROPERTY(bool isBand2ReleaseTimeImmutable READ isBand2ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2ReleaseTimeValue READ defaultBand2ReleaseTimeValue CONSTANT)
    /**
      Get band2ReleaseTime
    */
    double band2ReleaseTime() const
    {
      return mBand2ReleaseTime;
    }

    /**
      Is band2ReleaseTime Immutable
    */
    bool isBand2ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band2ReleaseTime" ) );
    }

    /**
      Get band2ReleaseTime default value
    */
    double defaultBand2ReleaseTimeValue() const
    {
        return defaultBand2ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand3ReleaseTime && !isBand3ReleaseTimeImmutable()) {
        mBand3ReleaseTime = v;
        Q_EMIT band3ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band3ReleaseTime READ band3ReleaseTime WRITE setBand3ReleaseTime NOTIFY band3ReleaseTimeChanged)
    Q_PROPERTY(bool isBand3ReleaseTimeImmutable READ isBand3ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3ReleaseTimeValue READ defaultBand3ReleaseTimeValue CONSTANT)
    /**
      Get band3ReleaseTime
    */
    double band3ReleaseTime() const
    {
      return mBand3ReleaseTime;
    }

    /**
      Is band3ReleaseTime Immutable
    */
    bool isBand3ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band3ReleaseTime" ) );
    }

    /**
      Get band3ReleaseTime default value
    */
    double defaultBand3ReleaseTimeValue() const
    {
        return defaultBand3ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand4ReleaseTime && !isBand4ReleaseTimeImmutable()) {
        mBand4ReleaseTime = v;
        Q_EMIT band4ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band4ReleaseTime READ band4ReleaseTime WRITE setBand4ReleaseTime NOTIFY band4ReleaseTimeChanged)
    Q_PROPERTY(bool isBand4ReleaseTimeImmutable READ isBand4ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4ReleaseTimeValue READ defaultBand4ReleaseTimeValue CONSTANT)
    /**
      Get band4ReleaseTime
    */
    double band4ReleaseTime() const
    {
      return mBand4ReleaseTime;
    }

    /**
      Is band4ReleaseTime Immutable
    */
    bool isBand4ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band4ReleaseTime" ) );
    }

    /**
      Get band4ReleaseTime default value
    */
    double defaultBand4ReleaseTimeValue() const
    {
        return defaultBand4ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand5ReleaseTime && !isBand5ReleaseTimeImmutable()) {
        mBand5ReleaseTime = v;
        Q_EMIT band5ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band5ReleaseTime READ band5ReleaseTime WRITE setBand5ReleaseTime NOTIFY band5ReleaseTimeChanged)
    Q_PROPERTY(bool isBand5ReleaseTimeImmutable READ isBand5ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5ReleaseTimeValue READ defaultBand5ReleaseTimeValue CONSTANT)
    /**
      Get band5ReleaseTime
    */
    double band5ReleaseTime() const
    {
      return mBand5ReleaseTime;
    }

    /**
      Is band5ReleaseTime Immutable
    */
    bool isBand5ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band5ReleaseTime" ) );
    }

    /**
      Get band5ReleaseTime default value
    */
    double defaultBand5ReleaseTimeValue() const
    {
        return defaultBand5ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand6ReleaseTime && !isBand6ReleaseTimeImmutable()) {
        mBand6ReleaseTime = v;
        Q_EMIT band6ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band6ReleaseTime READ band6ReleaseTime WRITE setBand6ReleaseTime NOTIFY band6ReleaseTimeChanged)
    Q_PROPERTY(bool isBand6ReleaseTimeImmutable READ isBand6ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6ReleaseTimeValue READ defaultBand6ReleaseTimeValue CONSTANT)
    /**
      Get band6ReleaseTime
    */
    double band6ReleaseTime() const
    {
      return mBand6ReleaseTime;
    }

    /**
      Is band6ReleaseTime Immutable
    */
    bool isBand6ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band6ReleaseTime" ) );
    }

    /**
      Get band6ReleaseTime default value
    */
    double defaultBand6ReleaseTimeValue() const
    {
        return defaultBand6ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand7ReleaseTime && !isBand7ReleaseTimeImmutable()) {
        mBand7ReleaseTime = v;
        Q_EMIT band7ReleaseTimeChanged();
      }
    }

    Q_PROPERTY(double band7ReleaseTime READ band7ReleaseTime WRITE setBand7ReleaseTime NOTIFY band7ReleaseTimeChanged)
    Q_PROPERTY(bool isBand7ReleaseTimeImmutable READ isBand7ReleaseTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7ReleaseTimeValue READ defaultBand7ReleaseTimeValue CONSTANT)
    /**
      Get band7ReleaseTime
    */
    double band7ReleaseTime() const
    {
      return mBand7ReleaseTime;
    }

    /**
      Is band7ReleaseTime Immutable
    */
    bool isBand7ReleaseTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "band7ReleaseTime" ) );
    }

    /**
      Get band7ReleaseTime default value
    */
    double defaultBand7ReleaseTimeValue() const
    {
        return defaultBand7ReleaseTimeValue_helper();
    }

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

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

      if (v != mBand0Ratio && !isBand0RatioImmutable()) {
        mBand0Ratio = v;
        Q_EMIT band0RatioChanged();
      }
    }

    Q_PROPERTY(double band0Ratio READ band0Ratio WRITE setBand0Ratio NOTIFY band0RatioChanged)
    Q_PROPERTY(bool isBand0RatioImmutable READ isBand0RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0RatioValue READ defaultBand0RatioValue CONSTANT)
    /**
      Get band0Ratio
    */
    double band0Ratio() const
    {
      return mBand0Ratio;
    }

    /**
      Is band0Ratio Immutable
    */
    bool isBand0RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band0Ratio" ) );
    }

    /**
      Get band0Ratio default value
    */
    double defaultBand0RatioValue() const
    {
        return defaultBand0RatioValue_helper();
    }

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

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

      if (v != mBand1Ratio && !isBand1RatioImmutable()) {
        mBand1Ratio = v;
        Q_EMIT band1RatioChanged();
      }
    }

    Q_PROPERTY(double band1Ratio READ band1Ratio WRITE setBand1Ratio NOTIFY band1RatioChanged)
    Q_PROPERTY(bool isBand1RatioImmutable READ isBand1RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1RatioValue READ defaultBand1RatioValue CONSTANT)
    /**
      Get band1Ratio
    */
    double band1Ratio() const
    {
      return mBand1Ratio;
    }

    /**
      Is band1Ratio Immutable
    */
    bool isBand1RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band1Ratio" ) );
    }

    /**
      Get band1Ratio default value
    */
    double defaultBand1RatioValue() const
    {
        return defaultBand1RatioValue_helper();
    }

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

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

      if (v != mBand2Ratio && !isBand2RatioImmutable()) {
        mBand2Ratio = v;
        Q_EMIT band2RatioChanged();
      }
    }

    Q_PROPERTY(double band2Ratio READ band2Ratio WRITE setBand2Ratio NOTIFY band2RatioChanged)
    Q_PROPERTY(bool isBand2RatioImmutable READ isBand2RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2RatioValue READ defaultBand2RatioValue CONSTANT)
    /**
      Get band2Ratio
    */
    double band2Ratio() const
    {
      return mBand2Ratio;
    }

    /**
      Is band2Ratio Immutable
    */
    bool isBand2RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band2Ratio" ) );
    }

    /**
      Get band2Ratio default value
    */
    double defaultBand2RatioValue() const
    {
        return defaultBand2RatioValue_helper();
    }

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

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

      if (v != mBand3Ratio && !isBand3RatioImmutable()) {
        mBand3Ratio = v;
        Q_EMIT band3RatioChanged();
      }
    }

    Q_PROPERTY(double band3Ratio READ band3Ratio WRITE setBand3Ratio NOTIFY band3RatioChanged)
    Q_PROPERTY(bool isBand3RatioImmutable READ isBand3RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3RatioValue READ defaultBand3RatioValue CONSTANT)
    /**
      Get band3Ratio
    */
    double band3Ratio() const
    {
      return mBand3Ratio;
    }

    /**
      Is band3Ratio Immutable
    */
    bool isBand3RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band3Ratio" ) );
    }

    /**
      Get band3Ratio default value
    */
    double defaultBand3RatioValue() const
    {
        return defaultBand3RatioValue_helper();
    }

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

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

      if (v != mBand4Ratio && !isBand4RatioImmutable()) {
        mBand4Ratio = v;
        Q_EMIT band4RatioChanged();
      }
    }

    Q_PROPERTY(double band4Ratio READ band4Ratio WRITE setBand4Ratio NOTIFY band4RatioChanged)
    Q_PROPERTY(bool isBand4RatioImmutable READ isBand4RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4RatioValue READ defaultBand4RatioValue CONSTANT)
    /**
      Get band4Ratio
    */
    double band4Ratio() const
    {
      return mBand4Ratio;
    }

    /**
      Is band4Ratio Immutable
    */
    bool isBand4RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band4Ratio" ) );
    }

    /**
      Get band4Ratio default value
    */
    double defaultBand4RatioValue() const
    {
        return defaultBand4RatioValue_helper();
    }

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

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

      if (v != mBand5Ratio && !isBand5RatioImmutable()) {
        mBand5Ratio = v;
        Q_EMIT band5RatioChanged();
      }
    }

    Q_PROPERTY(double band5Ratio READ band5Ratio WRITE setBand5Ratio NOTIFY band5RatioChanged)
    Q_PROPERTY(bool isBand5RatioImmutable READ isBand5RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5RatioValue READ defaultBand5RatioValue CONSTANT)
    /**
      Get band5Ratio
    */
    double band5Ratio() const
    {
      return mBand5Ratio;
    }

    /**
      Is band5Ratio Immutable
    */
    bool isBand5RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band5Ratio" ) );
    }

    /**
      Get band5Ratio default value
    */
    double defaultBand5RatioValue() const
    {
        return defaultBand5RatioValue_helper();
    }

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

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

      if (v != mBand6Ratio && !isBand6RatioImmutable()) {
        mBand6Ratio = v;
        Q_EMIT band6RatioChanged();
      }
    }

    Q_PROPERTY(double band6Ratio READ band6Ratio WRITE setBand6Ratio NOTIFY band6RatioChanged)
    Q_PROPERTY(bool isBand6RatioImmutable READ isBand6RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6RatioValue READ defaultBand6RatioValue CONSTANT)
    /**
      Get band6Ratio
    */
    double band6Ratio() const
    {
      return mBand6Ratio;
    }

    /**
      Is band6Ratio Immutable
    */
    bool isBand6RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band6Ratio" ) );
    }

    /**
      Get band6Ratio default value
    */
    double defaultBand6RatioValue() const
    {
        return defaultBand6RatioValue_helper();
    }

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

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

      if (v != mBand7Ratio && !isBand7RatioImmutable()) {
        mBand7Ratio = v;
        Q_EMIT band7RatioChanged();
      }
    }

    Q_PROPERTY(double band7Ratio READ band7Ratio WRITE setBand7Ratio NOTIFY band7RatioChanged)
    Q_PROPERTY(bool isBand7RatioImmutable READ isBand7RatioImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7RatioValue READ defaultBand7RatioValue CONSTANT)
    /**
      Get band7Ratio
    */
    double band7Ratio() const
    {
      return mBand7Ratio;
    }

    /**
      Is band7Ratio Immutable
    */
    bool isBand7RatioImmutable() const
    {
      return isImmutable( QStringLiteral( "band7Ratio" ) );
    }

    /**
      Get band7Ratio default value
    */
    double defaultBand7RatioValue() const
    {
        return defaultBand7RatioValue_helper();
    }

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

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

      if (v != mBand0Knee && !isBand0KneeImmutable()) {
        mBand0Knee = v;
        Q_EMIT band0KneeChanged();
      }
    }

    Q_PROPERTY(double band0Knee READ band0Knee WRITE setBand0Knee NOTIFY band0KneeChanged)
    Q_PROPERTY(bool isBand0KneeImmutable READ isBand0KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0KneeValue READ defaultBand0KneeValue CONSTANT)
    /**
      Get band0Knee
    */
    double band0Knee() const
    {
      return mBand0Knee;
    }

    /**
      Is band0Knee Immutable
    */
    bool isBand0KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band0Knee" ) );
    }

    /**
      Get band0Knee default value
    */
    double defaultBand0KneeValue() const
    {
        return defaultBand0KneeValue_helper();
    }

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

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

      if (v != mBand1Knee && !isBand1KneeImmutable()) {
        mBand1Knee = v;
        Q_EMIT band1KneeChanged();
      }
    }

    Q_PROPERTY(double band1Knee READ band1Knee WRITE setBand1Knee NOTIFY band1KneeChanged)
    Q_PROPERTY(bool isBand1KneeImmutable READ isBand1KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1KneeValue READ defaultBand1KneeValue CONSTANT)
    /**
      Get band1Knee
    */
    double band1Knee() const
    {
      return mBand1Knee;
    }

    /**
      Is band1Knee Immutable
    */
    bool isBand1KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band1Knee" ) );
    }

    /**
      Get band1Knee default value
    */
    double defaultBand1KneeValue() const
    {
        return defaultBand1KneeValue_helper();
    }

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

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

      if (v != mBand2Knee && !isBand2KneeImmutable()) {
        mBand2Knee = v;
        Q_EMIT band2KneeChanged();
      }
    }

    Q_PROPERTY(double band2Knee READ band2Knee WRITE setBand2Knee NOTIFY band2KneeChanged)
    Q_PROPERTY(bool isBand2KneeImmutable READ isBand2KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2KneeValue READ defaultBand2KneeValue CONSTANT)
    /**
      Get band2Knee
    */
    double band2Knee() const
    {
      return mBand2Knee;
    }

    /**
      Is band2Knee Immutable
    */
    bool isBand2KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band2Knee" ) );
    }

    /**
      Get band2Knee default value
    */
    double defaultBand2KneeValue() const
    {
        return defaultBand2KneeValue_helper();
    }

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

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

      if (v != mBand3Knee && !isBand3KneeImmutable()) {
        mBand3Knee = v;
        Q_EMIT band3KneeChanged();
      }
    }

    Q_PROPERTY(double band3Knee READ band3Knee WRITE setBand3Knee NOTIFY band3KneeChanged)
    Q_PROPERTY(bool isBand3KneeImmutable READ isBand3KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3KneeValue READ defaultBand3KneeValue CONSTANT)
    /**
      Get band3Knee
    */
    double band3Knee() const
    {
      return mBand3Knee;
    }

    /**
      Is band3Knee Immutable
    */
    bool isBand3KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band3Knee" ) );
    }

    /**
      Get band3Knee default value
    */
    double defaultBand3KneeValue() const
    {
        return defaultBand3KneeValue_helper();
    }

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

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

      if (v != mBand4Knee && !isBand4KneeImmutable()) {
        mBand4Knee = v;
        Q_EMIT band4KneeChanged();
      }
    }

    Q_PROPERTY(double band4Knee READ band4Knee WRITE setBand4Knee NOTIFY band4KneeChanged)
    Q_PROPERTY(bool isBand4KneeImmutable READ isBand4KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4KneeValue READ defaultBand4KneeValue CONSTANT)
    /**
      Get band4Knee
    */
    double band4Knee() const
    {
      return mBand4Knee;
    }

    /**
      Is band4Knee Immutable
    */
    bool isBand4KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band4Knee" ) );
    }

    /**
      Get band4Knee default value
    */
    double defaultBand4KneeValue() const
    {
        return defaultBand4KneeValue_helper();
    }

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

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

      if (v != mBand5Knee && !isBand5KneeImmutable()) {
        mBand5Knee = v;
        Q_EMIT band5KneeChanged();
      }
    }

    Q_PROPERTY(double band5Knee READ band5Knee WRITE setBand5Knee NOTIFY band5KneeChanged)
    Q_PROPERTY(bool isBand5KneeImmutable READ isBand5KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5KneeValue READ defaultBand5KneeValue CONSTANT)
    /**
      Get band5Knee
    */
    double band5Knee() const
    {
      return mBand5Knee;
    }

    /**
      Is band5Knee Immutable
    */
    bool isBand5KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band5Knee" ) );
    }

    /**
      Get band5Knee default value
    */
    double defaultBand5KneeValue() const
    {
        return defaultBand5KneeValue_helper();
    }

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

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

      if (v != mBand6Knee && !isBand6KneeImmutable()) {
        mBand6Knee = v;
        Q_EMIT band6KneeChanged();
      }
    }

    Q_PROPERTY(double band6Knee READ band6Knee WRITE setBand6Knee NOTIFY band6KneeChanged)
    Q_PROPERTY(bool isBand6KneeImmutable READ isBand6KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6KneeValue READ defaultBand6KneeValue CONSTANT)
    /**
      Get band6Knee
    */
    double band6Knee() const
    {
      return mBand6Knee;
    }

    /**
      Is band6Knee Immutable
    */
    bool isBand6KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band6Knee" ) );
    }

    /**
      Get band6Knee default value
    */
    double defaultBand6KneeValue() const
    {
        return defaultBand6KneeValue_helper();
    }

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

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

      if (v != mBand7Knee && !isBand7KneeImmutable()) {
        mBand7Knee = v;
        Q_EMIT band7KneeChanged();
      }
    }

    Q_PROPERTY(double band7Knee READ band7Knee WRITE setBand7Knee NOTIFY band7KneeChanged)
    Q_PROPERTY(bool isBand7KneeImmutable READ isBand7KneeImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7KneeValue READ defaultBand7KneeValue CONSTANT)
    /**
      Get band7Knee
    */
    double band7Knee() const
    {
      return mBand7Knee;
    }

    /**
      Is band7Knee Immutable
    */
    bool isBand7KneeImmutable() const
    {
      return isImmutable( QStringLiteral( "band7Knee" ) );
    }

    /**
      Get band7Knee default value
    */
    double defaultBand7KneeValue() const
    {
        return defaultBand7KneeValue_helper();
    }

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

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

      if (v != mBand0BoostThreshold && !isBand0BoostThresholdImmutable()) {
        mBand0BoostThreshold = v;
        Q_EMIT band0BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band0BoostThreshold READ band0BoostThreshold WRITE setBand0BoostThreshold NOTIFY band0BoostThresholdChanged)
    Q_PROPERTY(bool isBand0BoostThresholdImmutable READ isBand0BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0BoostThresholdValue READ defaultBand0BoostThresholdValue CONSTANT)
    /**
      Get band0BoostThreshold
    */
    double band0BoostThreshold() const
    {
      return mBand0BoostThreshold;
    }

    /**
      Is band0BoostThreshold Immutable
    */
    bool isBand0BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band0BoostThreshold" ) );
    }

    /**
      Get band0BoostThreshold default value
    */
    double defaultBand0BoostThresholdValue() const
    {
        return defaultBand0BoostThresholdValue_helper();
    }

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

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

      if (v != mBand1BoostThreshold && !isBand1BoostThresholdImmutable()) {
        mBand1BoostThreshold = v;
        Q_EMIT band1BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band1BoostThreshold READ band1BoostThreshold WRITE setBand1BoostThreshold NOTIFY band1BoostThresholdChanged)
    Q_PROPERTY(bool isBand1BoostThresholdImmutable READ isBand1BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1BoostThresholdValue READ defaultBand1BoostThresholdValue CONSTANT)
    /**
      Get band1BoostThreshold
    */
    double band1BoostThreshold() const
    {
      return mBand1BoostThreshold;
    }

    /**
      Is band1BoostThreshold Immutable
    */
    bool isBand1BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band1BoostThreshold" ) );
    }

    /**
      Get band1BoostThreshold default value
    */
    double defaultBand1BoostThresholdValue() const
    {
        return defaultBand1BoostThresholdValue_helper();
    }

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

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

      if (v != mBand2BoostThreshold && !isBand2BoostThresholdImmutable()) {
        mBand2BoostThreshold = v;
        Q_EMIT band2BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band2BoostThreshold READ band2BoostThreshold WRITE setBand2BoostThreshold NOTIFY band2BoostThresholdChanged)
    Q_PROPERTY(bool isBand2BoostThresholdImmutable READ isBand2BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2BoostThresholdValue READ defaultBand2BoostThresholdValue CONSTANT)
    /**
      Get band2BoostThreshold
    */
    double band2BoostThreshold() const
    {
      return mBand2BoostThreshold;
    }

    /**
      Is band2BoostThreshold Immutable
    */
    bool isBand2BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band2BoostThreshold" ) );
    }

    /**
      Get band2BoostThreshold default value
    */
    double defaultBand2BoostThresholdValue() const
    {
        return defaultBand2BoostThresholdValue_helper();
    }

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

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

      if (v != mBand3BoostThreshold && !isBand3BoostThresholdImmutable()) {
        mBand3BoostThreshold = v;
        Q_EMIT band3BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band3BoostThreshold READ band3BoostThreshold WRITE setBand3BoostThreshold NOTIFY band3BoostThresholdChanged)
    Q_PROPERTY(bool isBand3BoostThresholdImmutable READ isBand3BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3BoostThresholdValue READ defaultBand3BoostThresholdValue CONSTANT)
    /**
      Get band3BoostThreshold
    */
    double band3BoostThreshold() const
    {
      return mBand3BoostThreshold;
    }

    /**
      Is band3BoostThreshold Immutable
    */
    bool isBand3BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band3BoostThreshold" ) );
    }

    /**
      Get band3BoostThreshold default value
    */
    double defaultBand3BoostThresholdValue() const
    {
        return defaultBand3BoostThresholdValue_helper();
    }

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

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

      if (v != mBand4BoostThreshold && !isBand4BoostThresholdImmutable()) {
        mBand4BoostThreshold = v;
        Q_EMIT band4BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band4BoostThreshold READ band4BoostThreshold WRITE setBand4BoostThreshold NOTIFY band4BoostThresholdChanged)
    Q_PROPERTY(bool isBand4BoostThresholdImmutable READ isBand4BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4BoostThresholdValue READ defaultBand4BoostThresholdValue CONSTANT)
    /**
      Get band4BoostThreshold
    */
    double band4BoostThreshold() const
    {
      return mBand4BoostThreshold;
    }

    /**
      Is band4BoostThreshold Immutable
    */
    bool isBand4BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band4BoostThreshold" ) );
    }

    /**
      Get band4BoostThreshold default value
    */
    double defaultBand4BoostThresholdValue() const
    {
        return defaultBand4BoostThresholdValue_helper();
    }

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

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

      if (v != mBand5BoostThreshold && !isBand5BoostThresholdImmutable()) {
        mBand5BoostThreshold = v;
        Q_EMIT band5BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band5BoostThreshold READ band5BoostThreshold WRITE setBand5BoostThreshold NOTIFY band5BoostThresholdChanged)
    Q_PROPERTY(bool isBand5BoostThresholdImmutable READ isBand5BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5BoostThresholdValue READ defaultBand5BoostThresholdValue CONSTANT)
    /**
      Get band5BoostThreshold
    */
    double band5BoostThreshold() const
    {
      return mBand5BoostThreshold;
    }

    /**
      Is band5BoostThreshold Immutable
    */
    bool isBand5BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band5BoostThreshold" ) );
    }

    /**
      Get band5BoostThreshold default value
    */
    double defaultBand5BoostThresholdValue() const
    {
        return defaultBand5BoostThresholdValue_helper();
    }

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

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

      if (v != mBand6BoostThreshold && !isBand6BoostThresholdImmutable()) {
        mBand6BoostThreshold = v;
        Q_EMIT band6BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band6BoostThreshold READ band6BoostThreshold WRITE setBand6BoostThreshold NOTIFY band6BoostThresholdChanged)
    Q_PROPERTY(bool isBand6BoostThresholdImmutable READ isBand6BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6BoostThresholdValue READ defaultBand6BoostThresholdValue CONSTANT)
    /**
      Get band6BoostThreshold
    */
    double band6BoostThreshold() const
    {
      return mBand6BoostThreshold;
    }

    /**
      Is band6BoostThreshold Immutable
    */
    bool isBand6BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band6BoostThreshold" ) );
    }

    /**
      Get band6BoostThreshold default value
    */
    double defaultBand6BoostThresholdValue() const
    {
        return defaultBand6BoostThresholdValue_helper();
    }

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

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

      if (v != mBand7BoostThreshold && !isBand7BoostThresholdImmutable()) {
        mBand7BoostThreshold = v;
        Q_EMIT band7BoostThresholdChanged();
      }
    }

    Q_PROPERTY(double band7BoostThreshold READ band7BoostThreshold WRITE setBand7BoostThreshold NOTIFY band7BoostThresholdChanged)
    Q_PROPERTY(bool isBand7BoostThresholdImmutable READ isBand7BoostThresholdImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7BoostThresholdValue READ defaultBand7BoostThresholdValue CONSTANT)
    /**
      Get band7BoostThreshold
    */
    double band7BoostThreshold() const
    {
      return mBand7BoostThreshold;
    }

    /**
      Is band7BoostThreshold Immutable
    */
    bool isBand7BoostThresholdImmutable() const
    {
      return isImmutable( QStringLiteral( "band7BoostThreshold" ) );
    }

    /**
      Get band7BoostThreshold default value
    */
    double defaultBand7BoostThresholdValue() const
    {
        return defaultBand7BoostThresholdValue_helper();
    }

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

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

      if (v != mBand0BoostAmount && !isBand0BoostAmountImmutable()) {
        mBand0BoostAmount = v;
        Q_EMIT band0BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band0BoostAmount READ band0BoostAmount WRITE setBand0BoostAmount NOTIFY band0BoostAmountChanged)
    Q_PROPERTY(bool isBand0BoostAmountImmutable READ isBand0BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0BoostAmountValue READ defaultBand0BoostAmountValue CONSTANT)
    /**
      Get band0BoostAmount
    */
    double band0BoostAmount() const
    {
      return mBand0BoostAmount;
    }

    /**
      Is band0BoostAmount Immutable
    */
    bool isBand0BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band0BoostAmount" ) );
    }

    /**
      Get band0BoostAmount default value
    */
    double defaultBand0BoostAmountValue() const
    {
        return defaultBand0BoostAmountValue_helper();
    }

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

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

      if (v != mBand1BoostAmount && !isBand1BoostAmountImmutable()) {
        mBand1BoostAmount = v;
        Q_EMIT band1BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band1BoostAmount READ band1BoostAmount WRITE setBand1BoostAmount NOTIFY band1BoostAmountChanged)
    Q_PROPERTY(bool isBand1BoostAmountImmutable READ isBand1BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1BoostAmountValue READ defaultBand1BoostAmountValue CONSTANT)
    /**
      Get band1BoostAmount
    */
    double band1BoostAmount() const
    {
      return mBand1BoostAmount;
    }

    /**
      Is band1BoostAmount Immutable
    */
    bool isBand1BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band1BoostAmount" ) );
    }

    /**
      Get band1BoostAmount default value
    */
    double defaultBand1BoostAmountValue() const
    {
        return defaultBand1BoostAmountValue_helper();
    }

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

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

      if (v != mBand2BoostAmount && !isBand2BoostAmountImmutable()) {
        mBand2BoostAmount = v;
        Q_EMIT band2BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band2BoostAmount READ band2BoostAmount WRITE setBand2BoostAmount NOTIFY band2BoostAmountChanged)
    Q_PROPERTY(bool isBand2BoostAmountImmutable READ isBand2BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2BoostAmountValue READ defaultBand2BoostAmountValue CONSTANT)
    /**
      Get band2BoostAmount
    */
    double band2BoostAmount() const
    {
      return mBand2BoostAmount;
    }

    /**
      Is band2BoostAmount Immutable
    */
    bool isBand2BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band2BoostAmount" ) );
    }

    /**
      Get band2BoostAmount default value
    */
    double defaultBand2BoostAmountValue() const
    {
        return defaultBand2BoostAmountValue_helper();
    }

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

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

      if (v != mBand3BoostAmount && !isBand3BoostAmountImmutable()) {
        mBand3BoostAmount = v;
        Q_EMIT band3BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band3BoostAmount READ band3BoostAmount WRITE setBand3BoostAmount NOTIFY band3BoostAmountChanged)
    Q_PROPERTY(bool isBand3BoostAmountImmutable READ isBand3BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3BoostAmountValue READ defaultBand3BoostAmountValue CONSTANT)
    /**
      Get band3BoostAmount
    */
    double band3BoostAmount() const
    {
      return mBand3BoostAmount;
    }

    /**
      Is band3BoostAmount Immutable
    */
    bool isBand3BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band3BoostAmount" ) );
    }

    /**
      Get band3BoostAmount default value
    */
    double defaultBand3BoostAmountValue() const
    {
        return defaultBand3BoostAmountValue_helper();
    }

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

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

      if (v != mBand4BoostAmount && !isBand4BoostAmountImmutable()) {
        mBand4BoostAmount = v;
        Q_EMIT band4BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band4BoostAmount READ band4BoostAmount WRITE setBand4BoostAmount NOTIFY band4BoostAmountChanged)
    Q_PROPERTY(bool isBand4BoostAmountImmutable READ isBand4BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4BoostAmountValue READ defaultBand4BoostAmountValue CONSTANT)
    /**
      Get band4BoostAmount
    */
    double band4BoostAmount() const
    {
      return mBand4BoostAmount;
    }

    /**
      Is band4BoostAmount Immutable
    */
    bool isBand4BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band4BoostAmount" ) );
    }

    /**
      Get band4BoostAmount default value
    */
    double defaultBand4BoostAmountValue() const
    {
        return defaultBand4BoostAmountValue_helper();
    }

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

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

      if (v != mBand5BoostAmount && !isBand5BoostAmountImmutable()) {
        mBand5BoostAmount = v;
        Q_EMIT band5BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band5BoostAmount READ band5BoostAmount WRITE setBand5BoostAmount NOTIFY band5BoostAmountChanged)
    Q_PROPERTY(bool isBand5BoostAmountImmutable READ isBand5BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5BoostAmountValue READ defaultBand5BoostAmountValue CONSTANT)
    /**
      Get band5BoostAmount
    */
    double band5BoostAmount() const
    {
      return mBand5BoostAmount;
    }

    /**
      Is band5BoostAmount Immutable
    */
    bool isBand5BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band5BoostAmount" ) );
    }

    /**
      Get band5BoostAmount default value
    */
    double defaultBand5BoostAmountValue() const
    {
        return defaultBand5BoostAmountValue_helper();
    }

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

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

      if (v != mBand6BoostAmount && !isBand6BoostAmountImmutable()) {
        mBand6BoostAmount = v;
        Q_EMIT band6BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band6BoostAmount READ band6BoostAmount WRITE setBand6BoostAmount NOTIFY band6BoostAmountChanged)
    Q_PROPERTY(bool isBand6BoostAmountImmutable READ isBand6BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6BoostAmountValue READ defaultBand6BoostAmountValue CONSTANT)
    /**
      Get band6BoostAmount
    */
    double band6BoostAmount() const
    {
      return mBand6BoostAmount;
    }

    /**
      Is band6BoostAmount Immutable
    */
    bool isBand6BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band6BoostAmount" ) );
    }

    /**
      Get band6BoostAmount default value
    */
    double defaultBand6BoostAmountValue() const
    {
        return defaultBand6BoostAmountValue_helper();
    }

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

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

      if (v != mBand7BoostAmount && !isBand7BoostAmountImmutable()) {
        mBand7BoostAmount = v;
        Q_EMIT band7BoostAmountChanged();
      }
    }

    Q_PROPERTY(double band7BoostAmount READ band7BoostAmount WRITE setBand7BoostAmount NOTIFY band7BoostAmountChanged)
    Q_PROPERTY(bool isBand7BoostAmountImmutable READ isBand7BoostAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7BoostAmountValue READ defaultBand7BoostAmountValue CONSTANT)
    /**
      Get band7BoostAmount
    */
    double band7BoostAmount() const
    {
      return mBand7BoostAmount;
    }

    /**
      Is band7BoostAmount Immutable
    */
    bool isBand7BoostAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "band7BoostAmount" ) );
    }

    /**
      Get band7BoostAmount default value
    */
    double defaultBand7BoostAmountValue() const
    {
        return defaultBand7BoostAmountValue_helper();
    }

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

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

      if (v != mBand0Makeup && !isBand0MakeupImmutable()) {
        mBand0Makeup = v;
        Q_EMIT band0MakeupChanged();
      }
    }

    Q_PROPERTY(double band0Makeup READ band0Makeup WRITE setBand0Makeup NOTIFY band0MakeupChanged)
    Q_PROPERTY(bool isBand0MakeupImmutable READ isBand0MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand0MakeupValue READ defaultBand0MakeupValue CONSTANT)
    /**
      Get band0Makeup
    */
    double band0Makeup() const
    {
      return mBand0Makeup;
    }

    /**
      Is band0Makeup Immutable
    */
    bool isBand0MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band0Makeup" ) );
    }

    /**
      Get band0Makeup default value
    */
    double defaultBand0MakeupValue() const
    {
        return defaultBand0MakeupValue_helper();
    }

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

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

      if (v != mBand1Makeup && !isBand1MakeupImmutable()) {
        mBand1Makeup = v;
        Q_EMIT band1MakeupChanged();
      }
    }

    Q_PROPERTY(double band1Makeup READ band1Makeup WRITE setBand1Makeup NOTIFY band1MakeupChanged)
    Q_PROPERTY(bool isBand1MakeupImmutable READ isBand1MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand1MakeupValue READ defaultBand1MakeupValue CONSTANT)
    /**
      Get band1Makeup
    */
    double band1Makeup() const
    {
      return mBand1Makeup;
    }

    /**
      Is band1Makeup Immutable
    */
    bool isBand1MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band1Makeup" ) );
    }

    /**
      Get band1Makeup default value
    */
    double defaultBand1MakeupValue() const
    {
        return defaultBand1MakeupValue_helper();
    }

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

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

      if (v != mBand2Makeup && !isBand2MakeupImmutable()) {
        mBand2Makeup = v;
        Q_EMIT band2MakeupChanged();
      }
    }

    Q_PROPERTY(double band2Makeup READ band2Makeup WRITE setBand2Makeup NOTIFY band2MakeupChanged)
    Q_PROPERTY(bool isBand2MakeupImmutable READ isBand2MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand2MakeupValue READ defaultBand2MakeupValue CONSTANT)
    /**
      Get band2Makeup
    */
    double band2Makeup() const
    {
      return mBand2Makeup;
    }

    /**
      Is band2Makeup Immutable
    */
    bool isBand2MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band2Makeup" ) );
    }

    /**
      Get band2Makeup default value
    */
    double defaultBand2MakeupValue() const
    {
        return defaultBand2MakeupValue_helper();
    }

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

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

      if (v != mBand3Makeup && !isBand3MakeupImmutable()) {
        mBand3Makeup = v;
        Q_EMIT band3MakeupChanged();
      }
    }

    Q_PROPERTY(double band3Makeup READ band3Makeup WRITE setBand3Makeup NOTIFY band3MakeupChanged)
    Q_PROPERTY(bool isBand3MakeupImmutable READ isBand3MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand3MakeupValue READ defaultBand3MakeupValue CONSTANT)
    /**
      Get band3Makeup
    */
    double band3Makeup() const
    {
      return mBand3Makeup;
    }

    /**
      Is band3Makeup Immutable
    */
    bool isBand3MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band3Makeup" ) );
    }

    /**
      Get band3Makeup default value
    */
    double defaultBand3MakeupValue() const
    {
        return defaultBand3MakeupValue_helper();
    }

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

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

      if (v != mBand4Makeup && !isBand4MakeupImmutable()) {
        mBand4Makeup = v;
        Q_EMIT band4MakeupChanged();
      }
    }

    Q_PROPERTY(double band4Makeup READ band4Makeup WRITE setBand4Makeup NOTIFY band4MakeupChanged)
    Q_PROPERTY(bool isBand4MakeupImmutable READ isBand4MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand4MakeupValue READ defaultBand4MakeupValue CONSTANT)
    /**
      Get band4Makeup
    */
    double band4Makeup() const
    {
      return mBand4Makeup;
    }

    /**
      Is band4Makeup Immutable
    */
    bool isBand4MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band4Makeup" ) );
    }

    /**
      Get band4Makeup default value
    */
    double defaultBand4MakeupValue() const
    {
        return defaultBand4MakeupValue_helper();
    }

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

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

      if (v != mBand5Makeup && !isBand5MakeupImmutable()) {
        mBand5Makeup = v;
        Q_EMIT band5MakeupChanged();
      }
    }

    Q_PROPERTY(double band5Makeup READ band5Makeup WRITE setBand5Makeup NOTIFY band5MakeupChanged)
    Q_PROPERTY(bool isBand5MakeupImmutable READ isBand5MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand5MakeupValue READ defaultBand5MakeupValue CONSTANT)
    /**
      Get band5Makeup
    */
    double band5Makeup() const
    {
      return mBand5Makeup;
    }

    /**
      Is band5Makeup Immutable
    */
    bool isBand5MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band5Makeup" ) );
    }

    /**
      Get band5Makeup default value
    */
    double defaultBand5MakeupValue() const
    {
        return defaultBand5MakeupValue_helper();
    }

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

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

      if (v != mBand6Makeup && !isBand6MakeupImmutable()) {
        mBand6Makeup = v;
        Q_EMIT band6MakeupChanged();
      }
    }

    Q_PROPERTY(double band6Makeup READ band6Makeup WRITE setBand6Makeup NOTIFY band6MakeupChanged)
    Q_PROPERTY(bool isBand6MakeupImmutable READ isBand6MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand6MakeupValue READ defaultBand6MakeupValue CONSTANT)
    /**
      Get band6Makeup
    */
    double band6Makeup() const
    {
      return mBand6Makeup;
    }

    /**
      Is band6Makeup Immutable
    */
    bool isBand6MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band6Makeup" ) );
    }

    /**
      Get band6Makeup default value
    */
    double defaultBand6MakeupValue() const
    {
        return defaultBand6MakeupValue_helper();
    }

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

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

      if (v != mBand7Makeup && !isBand7MakeupImmutable()) {
        mBand7Makeup = v;
        Q_EMIT band7MakeupChanged();
      }
    }

    Q_PROPERTY(double band7Makeup READ band7Makeup WRITE setBand7Makeup NOTIFY band7MakeupChanged)
    Q_PROPERTY(bool isBand7MakeupImmutable READ isBand7MakeupImmutable CONSTANT)
    Q_PROPERTY(double defaultBand7MakeupValue READ defaultBand7MakeupValue CONSTANT)
    /**
      Get band7Makeup
    */
    double band7Makeup() const
    {
      return mBand7Makeup;
    }

    /**
      Is band7Makeup Immutable
    */
    bool isBand7MakeupImmutable() const
    {
      return isImmutable( QStringLiteral( "band7Makeup" ) );
    }

    /**
      Get band7Makeup default value
    */
    double defaultBand7MakeupValue() const
    {
        return defaultBand7MakeupValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalDryChanged = 4,
      signalWetChanged = 5,
      signalViewSidechainChanged = 6,
      signalExternalSidechainEnabledChanged = 7,
      signalStereoSplitChanged = 8,
      signalCompressorModeLabelsChanged = 9,
      signalCompressorModeChanged = 10,
      signalEnvelopeBoostLabelsChanged = 11,
      signalEnvelopeBoostChanged = 12,
      signalInputToSidechainChanged = 13,
      signalInputToLinkChanged = 14,
      signalSidechainToInputChanged = 15,
      signalSidechainToLinkChanged = 16,
      signalLinkToSidechainChanged = 17,
      signalLinkToInputChanged = 18,
      signalBand1EnableChanged = 19,
      signalBand2EnableChanged = 20,
      signalBand3EnableChanged = 21,
      signalBand4EnableChanged = 22,
      signalBand5EnableChanged = 23,
      signalBand6EnableChanged = 24,
      signalBand7EnableChanged = 25,
      signalBand1SplitFrequencyChanged = 26,
      signalBand2SplitFrequencyChanged = 27,
      signalBand3SplitFrequencyChanged = 28,
      signalBand4SplitFrequencyChanged = 29,
      signalBand5SplitFrequencyChanged = 30,
      signalBand6SplitFrequencyChanged = 31,
      signalBand7SplitFrequencyChanged = 32,
      signalSidechainInputDeviceChanged = 33,
      signalSidechainTypeLabelsChanged = 34,
      signalBand0SidechainTypeChanged = 35,
      signalBand1SidechainTypeChanged = 36,
      signalBand2SidechainTypeChanged = 37,
      signalBand3SidechainTypeChanged = 38,
      signalBand4SidechainTypeChanged = 39,
      signalBand5SidechainTypeChanged = 40,
      signalBand6SidechainTypeChanged = 41,
      signalBand7SidechainTypeChanged = 42,
      signalSidechainModeLabelsChanged = 43,
      signalBand0SidechainModeChanged = 44,
      signalBand1SidechainModeChanged = 45,
      signalBand2SidechainModeChanged = 46,
      signalBand3SidechainModeChanged = 47,
      signalBand4SidechainModeChanged = 48,
      signalBand5SidechainModeChanged = 49,
      signalBand6SidechainModeChanged = 50,
      signalBand7SidechainModeChanged = 51,
      signalSidechainSourceLabelsChanged = 52,
      signalBand0SidechainSourceChanged = 53,
      signalBand1SidechainSourceChanged = 54,
      signalBand2SidechainSourceChanged = 55,
      signalBand3SidechainSourceChanged = 56,
      signalBand4SidechainSourceChanged = 57,
      signalBand5SidechainSourceChanged = 58,
      signalBand6SidechainSourceChanged = 59,
      signalBand7SidechainSourceChanged = 60,
      signalStereoSplitSourceLabelsChanged = 61,
      signalBand0StereoSplitSourceChanged = 62,
      signalBand1StereoSplitSourceChanged = 63,
      signalBand2StereoSplitSourceChanged = 64,
      signalBand3StereoSplitSourceChanged = 65,
      signalBand4StereoSplitSourceChanged = 66,
      signalBand5StereoSplitSourceChanged = 67,
      signalBand6StereoSplitSourceChanged = 68,
      signalBand7StereoSplitSourceChanged = 69,
      signalBand0SidechainLookaheadChanged = 70,
      signalBand1SidechainLookaheadChanged = 71,
      signalBand2SidechainLookaheadChanged = 72,
      signalBand3SidechainLookaheadChanged = 73,
      signalBand4SidechainLookaheadChanged = 74,
      signalBand5SidechainLookaheadChanged = 75,
      signalBand6SidechainLookaheadChanged = 76,
      signalBand7SidechainLookaheadChanged = 77,
      signalBand0SidechainReactivityChanged = 78,
      signalBand1SidechainReactivityChanged = 79,
      signalBand2SidechainReactivityChanged = 80,
      signalBand3SidechainReactivityChanged = 81,
      signalBand4SidechainReactivityChanged = 82,
      signalBand5SidechainReactivityChanged = 83,
      signalBand6SidechainReactivityChanged = 84,
      signalBand7SidechainReactivityChanged = 85,
      signalBand0SidechainPreampChanged = 86,
      signalBand1SidechainPreampChanged = 87,
      signalBand2SidechainPreampChanged = 88,
      signalBand3SidechainPreampChanged = 89,
      signalBand4SidechainPreampChanged = 90,
      signalBand5SidechainPreampChanged = 91,
      signalBand6SidechainPreampChanged = 92,
      signalBand7SidechainPreampChanged = 93,
      signalBand0SidechainCustomLowcutFilterChanged = 94,
      signalBand1SidechainCustomLowcutFilterChanged = 95,
      signalBand2SidechainCustomLowcutFilterChanged = 96,
      signalBand3SidechainCustomLowcutFilterChanged = 97,
      signalBand4SidechainCustomLowcutFilterChanged = 98,
      signalBand5SidechainCustomLowcutFilterChanged = 99,
      signalBand6SidechainCustomLowcutFilterChanged = 100,
      signalBand7SidechainCustomLowcutFilterChanged = 101,
      signalBand0SidechainCustomHighcutFilterChanged = 102,
      signalBand1SidechainCustomHighcutFilterChanged = 103,
      signalBand2SidechainCustomHighcutFilterChanged = 104,
      signalBand3SidechainCustomHighcutFilterChanged = 105,
      signalBand4SidechainCustomHighcutFilterChanged = 106,
      signalBand5SidechainCustomHighcutFilterChanged = 107,
      signalBand6SidechainCustomHighcutFilterChanged = 108,
      signalBand7SidechainCustomHighcutFilterChanged = 109,
      signalBand0SidechainLowcutFrequencyChanged = 110,
      signalBand1SidechainLowcutFrequencyChanged = 111,
      signalBand2SidechainLowcutFrequencyChanged = 112,
      signalBand3SidechainLowcutFrequencyChanged = 113,
      signalBand4SidechainLowcutFrequencyChanged = 114,
      signalBand5SidechainLowcutFrequencyChanged = 115,
      signalBand6SidechainLowcutFrequencyChanged = 116,
      signalBand7SidechainLowcutFrequencyChanged = 117,
      signalBand0SidechainHighcutFrequencyChanged = 118,
      signalBand1SidechainHighcutFrequencyChanged = 119,
      signalBand2SidechainHighcutFrequencyChanged = 120,
      signalBand3SidechainHighcutFrequencyChanged = 121,
      signalBand4SidechainHighcutFrequencyChanged = 122,
      signalBand5SidechainHighcutFrequencyChanged = 123,
      signalBand6SidechainHighcutFrequencyChanged = 124,
      signalBand7SidechainHighcutFrequencyChanged = 125,
      signalCompressionModeLabelsChanged = 126,
      signalBand0CompressionModeChanged = 127,
      signalBand1CompressionModeChanged = 128,
      signalBand2CompressionModeChanged = 129,
      signalBand3CompressionModeChanged = 130,
      signalBand4CompressionModeChanged = 131,
      signalBand5CompressionModeChanged = 132,
      signalBand6CompressionModeChanged = 133,
      signalBand7CompressionModeChanged = 134,
      signalBand0CompressorEnableChanged = 135,
      signalBand1CompressorEnableChanged = 136,
      signalBand2CompressorEnableChanged = 137,
      signalBand3CompressorEnableChanged = 138,
      signalBand4CompressorEnableChanged = 139,
      signalBand5CompressorEnableChanged = 140,
      signalBand6CompressorEnableChanged = 141,
      signalBand7CompressorEnableChanged = 142,
      signalBand0SoloChanged = 143,
      signalBand1SoloChanged = 144,
      signalBand2SoloChanged = 145,
      signalBand3SoloChanged = 146,
      signalBand4SoloChanged = 147,
      signalBand5SoloChanged = 148,
      signalBand6SoloChanged = 149,
      signalBand7SoloChanged = 150,
      signalBand0MuteChanged = 151,
      signalBand1MuteChanged = 152,
      signalBand2MuteChanged = 153,
      signalBand3MuteChanged = 154,
      signalBand4MuteChanged = 155,
      signalBand5MuteChanged = 156,
      signalBand6MuteChanged = 157,
      signalBand7MuteChanged = 158,
      signalBand0AttackThresholdChanged = 159,
      signalBand1AttackThresholdChanged = 160,
      signalBand2AttackThresholdChanged = 161,
      signalBand3AttackThresholdChanged = 162,
      signalBand4AttackThresholdChanged = 163,
      signalBand5AttackThresholdChanged = 164,
      signalBand6AttackThresholdChanged = 165,
      signalBand7AttackThresholdChanged = 166,
      signalBand0AttackTimeChanged = 167,
      signalBand1AttackTimeChanged = 168,
      signalBand2AttackTimeChanged = 169,
      signalBand3AttackTimeChanged = 170,
      signalBand4AttackTimeChanged = 171,
      signalBand5AttackTimeChanged = 172,
      signalBand6AttackTimeChanged = 173,
      signalBand7AttackTimeChanged = 174,
      signalBand0ReleaseThresholdChanged = 175,
      signalBand1ReleaseThresholdChanged = 176,
      signalBand2ReleaseThresholdChanged = 177,
      signalBand3ReleaseThresholdChanged = 178,
      signalBand4ReleaseThresholdChanged = 179,
      signalBand5ReleaseThresholdChanged = 180,
      signalBand6ReleaseThresholdChanged = 181,
      signalBand7ReleaseThresholdChanged = 182,
      signalBand0ReleaseTimeChanged = 183,
      signalBand1ReleaseTimeChanged = 184,
      signalBand2ReleaseTimeChanged = 185,
      signalBand3ReleaseTimeChanged = 186,
      signalBand4ReleaseTimeChanged = 187,
      signalBand5ReleaseTimeChanged = 188,
      signalBand6ReleaseTimeChanged = 189,
      signalBand7ReleaseTimeChanged = 190,
      signalBand0RatioChanged = 191,
      signalBand1RatioChanged = 192,
      signalBand2RatioChanged = 193,
      signalBand3RatioChanged = 194,
      signalBand4RatioChanged = 195,
      signalBand5RatioChanged = 196,
      signalBand6RatioChanged = 197,
      signalBand7RatioChanged = 198,
      signalBand0KneeChanged = 199,
      signalBand1KneeChanged = 200,
      signalBand2KneeChanged = 201,
      signalBand3KneeChanged = 202,
      signalBand4KneeChanged = 203,
      signalBand5KneeChanged = 204,
      signalBand6KneeChanged = 205,
      signalBand7KneeChanged = 206,
      signalBand0BoostThresholdChanged = 207,
      signalBand1BoostThresholdChanged = 208,
      signalBand2BoostThresholdChanged = 209,
      signalBand3BoostThresholdChanged = 210,
      signalBand4BoostThresholdChanged = 211,
      signalBand5BoostThresholdChanged = 212,
      signalBand6BoostThresholdChanged = 213,
      signalBand7BoostThresholdChanged = 214,
      signalBand0BoostAmountChanged = 215,
      signalBand1BoostAmountChanged = 216,
      signalBand2BoostAmountChanged = 217,
      signalBand3BoostAmountChanged = 218,
      signalBand4BoostAmountChanged = 219,
      signalBand5BoostAmountChanged = 220,
      signalBand6BoostAmountChanged = 221,
      signalBand7BoostAmountChanged = 222,
      signalBand0MakeupChanged = 223,
      signalBand1MakeupChanged = 224,
      signalBand2MakeupChanged = 225,
      signalBand3MakeupChanged = 226,
      signalBand4MakeupChanged = 227,
      signalBand5MakeupChanged = 228,
      signalBand6MakeupChanged = 229,
      signalBand7MakeupChanged = 230
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void dryChanged();

    void wetChanged();

    void viewSidechainChanged();

    void externalSidechainEnabledChanged();

    void stereoSplitChanged();

    void compressorModeLabelsChanged();

    void compressorModeChanged();

    void envelopeBoostLabelsChanged();

    void envelopeBoostChanged();

    void inputToSidechainChanged();

    void inputToLinkChanged();

    void sidechainToInputChanged();

    void sidechainToLinkChanged();

    void linkToSidechainChanged();

    void linkToInputChanged();

    void band1EnableChanged();

    void band2EnableChanged();

    void band3EnableChanged();

    void band4EnableChanged();

    void band5EnableChanged();

    void band6EnableChanged();

    void band7EnableChanged();

    void band1SplitFrequencyChanged();

    void band2SplitFrequencyChanged();

    void band3SplitFrequencyChanged();

    void band4SplitFrequencyChanged();

    void band5SplitFrequencyChanged();

    void band6SplitFrequencyChanged();

    void band7SplitFrequencyChanged();

    void sidechainInputDeviceChanged();

    void sidechainTypeLabelsChanged();

    void band0SidechainTypeChanged();

    void band1SidechainTypeChanged();

    void band2SidechainTypeChanged();

    void band3SidechainTypeChanged();

    void band4SidechainTypeChanged();

    void band5SidechainTypeChanged();

    void band6SidechainTypeChanged();

    void band7SidechainTypeChanged();

    void sidechainModeLabelsChanged();

    void band0SidechainModeChanged();

    void band1SidechainModeChanged();

    void band2SidechainModeChanged();

    void band3SidechainModeChanged();

    void band4SidechainModeChanged();

    void band5SidechainModeChanged();

    void band6SidechainModeChanged();

    void band7SidechainModeChanged();

    void sidechainSourceLabelsChanged();

    void band0SidechainSourceChanged();

    void band1SidechainSourceChanged();

    void band2SidechainSourceChanged();

    void band3SidechainSourceChanged();

    void band4SidechainSourceChanged();

    void band5SidechainSourceChanged();

    void band6SidechainSourceChanged();

    void band7SidechainSourceChanged();

    void stereoSplitSourceLabelsChanged();

    void band0StereoSplitSourceChanged();

    void band1StereoSplitSourceChanged();

    void band2StereoSplitSourceChanged();

    void band3StereoSplitSourceChanged();

    void band4StereoSplitSourceChanged();

    void band5StereoSplitSourceChanged();

    void band6StereoSplitSourceChanged();

    void band7StereoSplitSourceChanged();

    void band0SidechainLookaheadChanged();

    void band1SidechainLookaheadChanged();

    void band2SidechainLookaheadChanged();

    void band3SidechainLookaheadChanged();

    void band4SidechainLookaheadChanged();

    void band5SidechainLookaheadChanged();

    void band6SidechainLookaheadChanged();

    void band7SidechainLookaheadChanged();

    void band0SidechainReactivityChanged();

    void band1SidechainReactivityChanged();

    void band2SidechainReactivityChanged();

    void band3SidechainReactivityChanged();

    void band4SidechainReactivityChanged();

    void band5SidechainReactivityChanged();

    void band6SidechainReactivityChanged();

    void band7SidechainReactivityChanged();

    void band0SidechainPreampChanged();

    void band1SidechainPreampChanged();

    void band2SidechainPreampChanged();

    void band3SidechainPreampChanged();

    void band4SidechainPreampChanged();

    void band5SidechainPreampChanged();

    void band6SidechainPreampChanged();

    void band7SidechainPreampChanged();

    void band0SidechainCustomLowcutFilterChanged();

    void band1SidechainCustomLowcutFilterChanged();

    void band2SidechainCustomLowcutFilterChanged();

    void band3SidechainCustomLowcutFilterChanged();

    void band4SidechainCustomLowcutFilterChanged();

    void band5SidechainCustomLowcutFilterChanged();

    void band6SidechainCustomLowcutFilterChanged();

    void band7SidechainCustomLowcutFilterChanged();

    void band0SidechainCustomHighcutFilterChanged();

    void band1SidechainCustomHighcutFilterChanged();

    void band2SidechainCustomHighcutFilterChanged();

    void band3SidechainCustomHighcutFilterChanged();

    void band4SidechainCustomHighcutFilterChanged();

    void band5SidechainCustomHighcutFilterChanged();

    void band6SidechainCustomHighcutFilterChanged();

    void band7SidechainCustomHighcutFilterChanged();

    void band0SidechainLowcutFrequencyChanged();

    void band1SidechainLowcutFrequencyChanged();

    void band2SidechainLowcutFrequencyChanged();

    void band3SidechainLowcutFrequencyChanged();

    void band4SidechainLowcutFrequencyChanged();

    void band5SidechainLowcutFrequencyChanged();

    void band6SidechainLowcutFrequencyChanged();

    void band7SidechainLowcutFrequencyChanged();

    void band0SidechainHighcutFrequencyChanged();

    void band1SidechainHighcutFrequencyChanged();

    void band2SidechainHighcutFrequencyChanged();

    void band3SidechainHighcutFrequencyChanged();

    void band4SidechainHighcutFrequencyChanged();

    void band5SidechainHighcutFrequencyChanged();

    void band6SidechainHighcutFrequencyChanged();

    void band7SidechainHighcutFrequencyChanged();

    void compressionModeLabelsChanged();

    void band0CompressionModeChanged();

    void band1CompressionModeChanged();

    void band2CompressionModeChanged();

    void band3CompressionModeChanged();

    void band4CompressionModeChanged();

    void band5CompressionModeChanged();

    void band6CompressionModeChanged();

    void band7CompressionModeChanged();

    void band0CompressorEnableChanged();

    void band1CompressorEnableChanged();

    void band2CompressorEnableChanged();

    void band3CompressorEnableChanged();

    void band4CompressorEnableChanged();

    void band5CompressorEnableChanged();

    void band6CompressorEnableChanged();

    void band7CompressorEnableChanged();

    void band0SoloChanged();

    void band1SoloChanged();

    void band2SoloChanged();

    void band3SoloChanged();

    void band4SoloChanged();

    void band5SoloChanged();

    void band6SoloChanged();

    void band7SoloChanged();

    void band0MuteChanged();

    void band1MuteChanged();

    void band2MuteChanged();

    void band3MuteChanged();

    void band4MuteChanged();

    void band5MuteChanged();

    void band6MuteChanged();

    void band7MuteChanged();

    void band0AttackThresholdChanged();

    void band1AttackThresholdChanged();

    void band2AttackThresholdChanged();

    void band3AttackThresholdChanged();

    void band4AttackThresholdChanged();

    void band5AttackThresholdChanged();

    void band6AttackThresholdChanged();

    void band7AttackThresholdChanged();

    void band0AttackTimeChanged();

    void band1AttackTimeChanged();

    void band2AttackTimeChanged();

    void band3AttackTimeChanged();

    void band4AttackTimeChanged();

    void band5AttackTimeChanged();

    void band6AttackTimeChanged();

    void band7AttackTimeChanged();

    void band0ReleaseThresholdChanged();

    void band1ReleaseThresholdChanged();

    void band2ReleaseThresholdChanged();

    void band3ReleaseThresholdChanged();

    void band4ReleaseThresholdChanged();

    void band5ReleaseThresholdChanged();

    void band6ReleaseThresholdChanged();

    void band7ReleaseThresholdChanged();

    void band0ReleaseTimeChanged();

    void band1ReleaseTimeChanged();

    void band2ReleaseTimeChanged();

    void band3ReleaseTimeChanged();

    void band4ReleaseTimeChanged();

    void band5ReleaseTimeChanged();

    void band6ReleaseTimeChanged();

    void band7ReleaseTimeChanged();

    void band0RatioChanged();

    void band1RatioChanged();

    void band2RatioChanged();

    void band3RatioChanged();

    void band4RatioChanged();

    void band5RatioChanged();

    void band6RatioChanged();

    void band7RatioChanged();

    void band0KneeChanged();

    void band1KneeChanged();

    void band2KneeChanged();

    void band3KneeChanged();

    void band4KneeChanged();

    void band5KneeChanged();

    void band6KneeChanged();

    void band7KneeChanged();

    void band0BoostThresholdChanged();

    void band1BoostThresholdChanged();

    void band2BoostThresholdChanged();

    void band3BoostThresholdChanged();

    void band4BoostThresholdChanged();

    void band5BoostThresholdChanged();

    void band6BoostThresholdChanged();

    void band7BoostThresholdChanged();

    void band0BoostAmountChanged();

    void band1BoostAmountChanged();

    void band2BoostAmountChanged();

    void band3BoostAmountChanged();

    void band4BoostAmountChanged();

    void band5BoostAmountChanged();

    void band6BoostAmountChanged();

    void band7BoostAmountChanged();

    void band0MakeupChanged();

    void band1MakeupChanged();

    void band2MakeupChanged();

    void band3MakeupChanged();

    void band4MakeupChanged();

    void band5MakeupChanged();

    void band6MakeupChanged();

    void band7MakeupChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // MultibandCompressor#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    double mDry;
    double defaultDryValue_helper() const;
    double mWet;
    double defaultWetValue_helper() const;
    bool mViewSidechain;
    bool defaultViewSidechainValue_helper() const;
    bool mExternalSidechainEnabled;
    bool defaultExternalSidechainEnabledValue_helper() const;
    bool mStereoSplit;
    bool defaultStereoSplitValue_helper() const;
    QStringList mCompressorModeLabels;
    QStringList defaultCompressorModeLabelsValue_helper() const;
    int mCompressorMode;
    int defaultCompressorModeValue_helper() const;
    QStringList mEnvelopeBoostLabels;
    QStringList defaultEnvelopeBoostLabelsValue_helper() const;
    int mEnvelopeBoost;
    int defaultEnvelopeBoostValue_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;
    bool mBand1Enable;
    bool defaultBand1EnableValue_helper() const;
    bool mBand2Enable;
    bool defaultBand2EnableValue_helper() const;
    bool mBand3Enable;
    bool defaultBand3EnableValue_helper() const;
    bool mBand4Enable;
    bool defaultBand4EnableValue_helper() const;
    bool mBand5Enable;
    bool defaultBand5EnableValue_helper() const;
    bool mBand6Enable;
    bool defaultBand6EnableValue_helper() const;
    bool mBand7Enable;
    bool defaultBand7EnableValue_helper() const;
    double mBand1SplitFrequency;
    double defaultBand1SplitFrequencyValue_helper() const;
    double mBand2SplitFrequency;
    double defaultBand2SplitFrequencyValue_helper() const;
    double mBand3SplitFrequency;
    double defaultBand3SplitFrequencyValue_helper() const;
    double mBand4SplitFrequency;
    double defaultBand4SplitFrequencyValue_helper() const;
    double mBand5SplitFrequency;
    double defaultBand5SplitFrequencyValue_helper() const;
    double mBand6SplitFrequency;
    double defaultBand6SplitFrequencyValue_helper() const;
    double mBand7SplitFrequency;
    double defaultBand7SplitFrequencyValue_helper() const;
    QString mSidechainInputDevice;
    QString defaultSidechainInputDeviceValue_helper() const;
    QStringList mSidechainTypeLabels;
    QStringList defaultSidechainTypeLabelsValue_helper() const;
    int mBand0SidechainType;
    int defaultBand0SidechainTypeValue_helper() const;
    int mBand1SidechainType;
    int defaultBand1SidechainTypeValue_helper() const;
    int mBand2SidechainType;
    int defaultBand2SidechainTypeValue_helper() const;
    int mBand3SidechainType;
    int defaultBand3SidechainTypeValue_helper() const;
    int mBand4SidechainType;
    int defaultBand4SidechainTypeValue_helper() const;
    int mBand5SidechainType;
    int defaultBand5SidechainTypeValue_helper() const;
    int mBand6SidechainType;
    int defaultBand6SidechainTypeValue_helper() const;
    int mBand7SidechainType;
    int defaultBand7SidechainTypeValue_helper() const;
    QStringList mSidechainModeLabels;
    QStringList defaultSidechainModeLabelsValue_helper() const;
    int mBand0SidechainMode;
    int defaultBand0SidechainModeValue_helper() const;
    int mBand1SidechainMode;
    int defaultBand1SidechainModeValue_helper() const;
    int mBand2SidechainMode;
    int defaultBand2SidechainModeValue_helper() const;
    int mBand3SidechainMode;
    int defaultBand3SidechainModeValue_helper() const;
    int mBand4SidechainMode;
    int defaultBand4SidechainModeValue_helper() const;
    int mBand5SidechainMode;
    int defaultBand5SidechainModeValue_helper() const;
    int mBand6SidechainMode;
    int defaultBand6SidechainModeValue_helper() const;
    int mBand7SidechainMode;
    int defaultBand7SidechainModeValue_helper() const;
    QStringList mSidechainSourceLabels;
    QStringList defaultSidechainSourceLabelsValue_helper() const;
    int mBand0SidechainSource;
    int defaultBand0SidechainSourceValue_helper() const;
    int mBand1SidechainSource;
    int defaultBand1SidechainSourceValue_helper() const;
    int mBand2SidechainSource;
    int defaultBand2SidechainSourceValue_helper() const;
    int mBand3SidechainSource;
    int defaultBand3SidechainSourceValue_helper() const;
    int mBand4SidechainSource;
    int defaultBand4SidechainSourceValue_helper() const;
    int mBand5SidechainSource;
    int defaultBand5SidechainSourceValue_helper() const;
    int mBand6SidechainSource;
    int defaultBand6SidechainSourceValue_helper() const;
    int mBand7SidechainSource;
    int defaultBand7SidechainSourceValue_helper() const;
    QStringList mStereoSplitSourceLabels;
    QStringList defaultStereoSplitSourceLabelsValue_helper() const;
    int mBand0StereoSplitSource;
    int defaultBand0StereoSplitSourceValue_helper() const;
    int mBand1StereoSplitSource;
    int defaultBand1StereoSplitSourceValue_helper() const;
    int mBand2StereoSplitSource;
    int defaultBand2StereoSplitSourceValue_helper() const;
    int mBand3StereoSplitSource;
    int defaultBand3StereoSplitSourceValue_helper() const;
    int mBand4StereoSplitSource;
    int defaultBand4StereoSplitSourceValue_helper() const;
    int mBand5StereoSplitSource;
    int defaultBand5StereoSplitSourceValue_helper() const;
    int mBand6StereoSplitSource;
    int defaultBand6StereoSplitSourceValue_helper() const;
    int mBand7StereoSplitSource;
    int defaultBand7StereoSplitSourceValue_helper() const;
    double mBand0SidechainLookahead;
    double defaultBand0SidechainLookaheadValue_helper() const;
    double mBand1SidechainLookahead;
    double defaultBand1SidechainLookaheadValue_helper() const;
    double mBand2SidechainLookahead;
    double defaultBand2SidechainLookaheadValue_helper() const;
    double mBand3SidechainLookahead;
    double defaultBand3SidechainLookaheadValue_helper() const;
    double mBand4SidechainLookahead;
    double defaultBand4SidechainLookaheadValue_helper() const;
    double mBand5SidechainLookahead;
    double defaultBand5SidechainLookaheadValue_helper() const;
    double mBand6SidechainLookahead;
    double defaultBand6SidechainLookaheadValue_helper() const;
    double mBand7SidechainLookahead;
    double defaultBand7SidechainLookaheadValue_helper() const;
    double mBand0SidechainReactivity;
    double defaultBand0SidechainReactivityValue_helper() const;
    double mBand1SidechainReactivity;
    double defaultBand1SidechainReactivityValue_helper() const;
    double mBand2SidechainReactivity;
    double defaultBand2SidechainReactivityValue_helper() const;
    double mBand3SidechainReactivity;
    double defaultBand3SidechainReactivityValue_helper() const;
    double mBand4SidechainReactivity;
    double defaultBand4SidechainReactivityValue_helper() const;
    double mBand5SidechainReactivity;
    double defaultBand5SidechainReactivityValue_helper() const;
    double mBand6SidechainReactivity;
    double defaultBand6SidechainReactivityValue_helper() const;
    double mBand7SidechainReactivity;
    double defaultBand7SidechainReactivityValue_helper() const;
    double mBand0SidechainPreamp;
    double defaultBand0SidechainPreampValue_helper() const;
    double mBand1SidechainPreamp;
    double defaultBand1SidechainPreampValue_helper() const;
    double mBand2SidechainPreamp;
    double defaultBand2SidechainPreampValue_helper() const;
    double mBand3SidechainPreamp;
    double defaultBand3SidechainPreampValue_helper() const;
    double mBand4SidechainPreamp;
    double defaultBand4SidechainPreampValue_helper() const;
    double mBand5SidechainPreamp;
    double defaultBand5SidechainPreampValue_helper() const;
    double mBand6SidechainPreamp;
    double defaultBand6SidechainPreampValue_helper() const;
    double mBand7SidechainPreamp;
    double defaultBand7SidechainPreampValue_helper() const;
    bool mBand0SidechainCustomLowcutFilter;
    bool defaultBand0SidechainCustomLowcutFilterValue_helper() const;
    bool mBand1SidechainCustomLowcutFilter;
    bool defaultBand1SidechainCustomLowcutFilterValue_helper() const;
    bool mBand2SidechainCustomLowcutFilter;
    bool defaultBand2SidechainCustomLowcutFilterValue_helper() const;
    bool mBand3SidechainCustomLowcutFilter;
    bool defaultBand3SidechainCustomLowcutFilterValue_helper() const;
    bool mBand4SidechainCustomLowcutFilter;
    bool defaultBand4SidechainCustomLowcutFilterValue_helper() const;
    bool mBand5SidechainCustomLowcutFilter;
    bool defaultBand5SidechainCustomLowcutFilterValue_helper() const;
    bool mBand6SidechainCustomLowcutFilter;
    bool defaultBand6SidechainCustomLowcutFilterValue_helper() const;
    bool mBand7SidechainCustomLowcutFilter;
    bool defaultBand7SidechainCustomLowcutFilterValue_helper() const;
    bool mBand0SidechainCustomHighcutFilter;
    bool defaultBand0SidechainCustomHighcutFilterValue_helper() const;
    bool mBand1SidechainCustomHighcutFilter;
    bool defaultBand1SidechainCustomHighcutFilterValue_helper() const;
    bool mBand2SidechainCustomHighcutFilter;
    bool defaultBand2SidechainCustomHighcutFilterValue_helper() const;
    bool mBand3SidechainCustomHighcutFilter;
    bool defaultBand3SidechainCustomHighcutFilterValue_helper() const;
    bool mBand4SidechainCustomHighcutFilter;
    bool defaultBand4SidechainCustomHighcutFilterValue_helper() const;
    bool mBand5SidechainCustomHighcutFilter;
    bool defaultBand5SidechainCustomHighcutFilterValue_helper() const;
    bool mBand6SidechainCustomHighcutFilter;
    bool defaultBand6SidechainCustomHighcutFilterValue_helper() const;
    bool mBand7SidechainCustomHighcutFilter;
    bool defaultBand7SidechainCustomHighcutFilterValue_helper() const;
    double mBand0SidechainLowcutFrequency;
    double defaultBand0SidechainLowcutFrequencyValue_helper() const;
    double mBand1SidechainLowcutFrequency;
    double defaultBand1SidechainLowcutFrequencyValue_helper() const;
    double mBand2SidechainLowcutFrequency;
    double defaultBand2SidechainLowcutFrequencyValue_helper() const;
    double mBand3SidechainLowcutFrequency;
    double defaultBand3SidechainLowcutFrequencyValue_helper() const;
    double mBand4SidechainLowcutFrequency;
    double defaultBand4SidechainLowcutFrequencyValue_helper() const;
    double mBand5SidechainLowcutFrequency;
    double defaultBand5SidechainLowcutFrequencyValue_helper() const;
    double mBand6SidechainLowcutFrequency;
    double defaultBand6SidechainLowcutFrequencyValue_helper() const;
    double mBand7SidechainLowcutFrequency;
    double defaultBand7SidechainLowcutFrequencyValue_helper() const;
    double mBand0SidechainHighcutFrequency;
    double defaultBand0SidechainHighcutFrequencyValue_helper() const;
    double mBand1SidechainHighcutFrequency;
    double defaultBand1SidechainHighcutFrequencyValue_helper() const;
    double mBand2SidechainHighcutFrequency;
    double defaultBand2SidechainHighcutFrequencyValue_helper() const;
    double mBand3SidechainHighcutFrequency;
    double defaultBand3SidechainHighcutFrequencyValue_helper() const;
    double mBand4SidechainHighcutFrequency;
    double defaultBand4SidechainHighcutFrequencyValue_helper() const;
    double mBand5SidechainHighcutFrequency;
    double defaultBand5SidechainHighcutFrequencyValue_helper() const;
    double mBand6SidechainHighcutFrequency;
    double defaultBand6SidechainHighcutFrequencyValue_helper() const;
    double mBand7SidechainHighcutFrequency;
    double defaultBand7SidechainHighcutFrequencyValue_helper() const;
    QStringList mCompressionModeLabels;
    QStringList defaultCompressionModeLabelsValue_helper() const;
    int mBand0CompressionMode;
    int defaultBand0CompressionModeValue_helper() const;
    int mBand1CompressionMode;
    int defaultBand1CompressionModeValue_helper() const;
    int mBand2CompressionMode;
    int defaultBand2CompressionModeValue_helper() const;
    int mBand3CompressionMode;
    int defaultBand3CompressionModeValue_helper() const;
    int mBand4CompressionMode;
    int defaultBand4CompressionModeValue_helper() const;
    int mBand5CompressionMode;
    int defaultBand5CompressionModeValue_helper() const;
    int mBand6CompressionMode;
    int defaultBand6CompressionModeValue_helper() const;
    int mBand7CompressionMode;
    int defaultBand7CompressionModeValue_helper() const;
    bool mBand0CompressorEnable;
    bool defaultBand0CompressorEnableValue_helper() const;
    bool mBand1CompressorEnable;
    bool defaultBand1CompressorEnableValue_helper() const;
    bool mBand2CompressorEnable;
    bool defaultBand2CompressorEnableValue_helper() const;
    bool mBand3CompressorEnable;
    bool defaultBand3CompressorEnableValue_helper() const;
    bool mBand4CompressorEnable;
    bool defaultBand4CompressorEnableValue_helper() const;
    bool mBand5CompressorEnable;
    bool defaultBand5CompressorEnableValue_helper() const;
    bool mBand6CompressorEnable;
    bool defaultBand6CompressorEnableValue_helper() const;
    bool mBand7CompressorEnable;
    bool defaultBand7CompressorEnableValue_helper() const;
    bool mBand0Solo;
    bool defaultBand0SoloValue_helper() const;
    bool mBand1Solo;
    bool defaultBand1SoloValue_helper() const;
    bool mBand2Solo;
    bool defaultBand2SoloValue_helper() const;
    bool mBand3Solo;
    bool defaultBand3SoloValue_helper() const;
    bool mBand4Solo;
    bool defaultBand4SoloValue_helper() const;
    bool mBand5Solo;
    bool defaultBand5SoloValue_helper() const;
    bool mBand6Solo;
    bool defaultBand6SoloValue_helper() const;
    bool mBand7Solo;
    bool defaultBand7SoloValue_helper() const;
    bool mBand0Mute;
    bool defaultBand0MuteValue_helper() const;
    bool mBand1Mute;
    bool defaultBand1MuteValue_helper() const;
    bool mBand2Mute;
    bool defaultBand2MuteValue_helper() const;
    bool mBand3Mute;
    bool defaultBand3MuteValue_helper() const;
    bool mBand4Mute;
    bool defaultBand4MuteValue_helper() const;
    bool mBand5Mute;
    bool defaultBand5MuteValue_helper() const;
    bool mBand6Mute;
    bool defaultBand6MuteValue_helper() const;
    bool mBand7Mute;
    bool defaultBand7MuteValue_helper() const;
    double mBand0AttackThreshold;
    double defaultBand0AttackThresholdValue_helper() const;
    double mBand1AttackThreshold;
    double defaultBand1AttackThresholdValue_helper() const;
    double mBand2AttackThreshold;
    double defaultBand2AttackThresholdValue_helper() const;
    double mBand3AttackThreshold;
    double defaultBand3AttackThresholdValue_helper() const;
    double mBand4AttackThreshold;
    double defaultBand4AttackThresholdValue_helper() const;
    double mBand5AttackThreshold;
    double defaultBand5AttackThresholdValue_helper() const;
    double mBand6AttackThreshold;
    double defaultBand6AttackThresholdValue_helper() const;
    double mBand7AttackThreshold;
    double defaultBand7AttackThresholdValue_helper() const;
    double mBand0AttackTime;
    double defaultBand0AttackTimeValue_helper() const;
    double mBand1AttackTime;
    double defaultBand1AttackTimeValue_helper() const;
    double mBand2AttackTime;
    double defaultBand2AttackTimeValue_helper() const;
    double mBand3AttackTime;
    double defaultBand3AttackTimeValue_helper() const;
    double mBand4AttackTime;
    double defaultBand4AttackTimeValue_helper() const;
    double mBand5AttackTime;
    double defaultBand5AttackTimeValue_helper() const;
    double mBand6AttackTime;
    double defaultBand6AttackTimeValue_helper() const;
    double mBand7AttackTime;
    double defaultBand7AttackTimeValue_helper() const;
    double mBand0ReleaseThreshold;
    double defaultBand0ReleaseThresholdValue_helper() const;
    double mBand1ReleaseThreshold;
    double defaultBand1ReleaseThresholdValue_helper() const;
    double mBand2ReleaseThreshold;
    double defaultBand2ReleaseThresholdValue_helper() const;
    double mBand3ReleaseThreshold;
    double defaultBand3ReleaseThresholdValue_helper() const;
    double mBand4ReleaseThreshold;
    double defaultBand4ReleaseThresholdValue_helper() const;
    double mBand5ReleaseThreshold;
    double defaultBand5ReleaseThresholdValue_helper() const;
    double mBand6ReleaseThreshold;
    double defaultBand6ReleaseThresholdValue_helper() const;
    double mBand7ReleaseThreshold;
    double defaultBand7ReleaseThresholdValue_helper() const;
    double mBand0ReleaseTime;
    double defaultBand0ReleaseTimeValue_helper() const;
    double mBand1ReleaseTime;
    double defaultBand1ReleaseTimeValue_helper() const;
    double mBand2ReleaseTime;
    double defaultBand2ReleaseTimeValue_helper() const;
    double mBand3ReleaseTime;
    double defaultBand3ReleaseTimeValue_helper() const;
    double mBand4ReleaseTime;
    double defaultBand4ReleaseTimeValue_helper() const;
    double mBand5ReleaseTime;
    double defaultBand5ReleaseTimeValue_helper() const;
    double mBand6ReleaseTime;
    double defaultBand6ReleaseTimeValue_helper() const;
    double mBand7ReleaseTime;
    double defaultBand7ReleaseTimeValue_helper() const;
    double mBand0Ratio;
    double defaultBand0RatioValue_helper() const;
    double mBand1Ratio;
    double defaultBand1RatioValue_helper() const;
    double mBand2Ratio;
    double defaultBand2RatioValue_helper() const;
    double mBand3Ratio;
    double defaultBand3RatioValue_helper() const;
    double mBand4Ratio;
    double defaultBand4RatioValue_helper() const;
    double mBand5Ratio;
    double defaultBand5RatioValue_helper() const;
    double mBand6Ratio;
    double defaultBand6RatioValue_helper() const;
    double mBand7Ratio;
    double defaultBand7RatioValue_helper() const;
    double mBand0Knee;
    double defaultBand0KneeValue_helper() const;
    double mBand1Knee;
    double defaultBand1KneeValue_helper() const;
    double mBand2Knee;
    double defaultBand2KneeValue_helper() const;
    double mBand3Knee;
    double defaultBand3KneeValue_helper() const;
    double mBand4Knee;
    double defaultBand4KneeValue_helper() const;
    double mBand5Knee;
    double defaultBand5KneeValue_helper() const;
    double mBand6Knee;
    double defaultBand6KneeValue_helper() const;
    double mBand7Knee;
    double defaultBand7KneeValue_helper() const;
    double mBand0BoostThreshold;
    double defaultBand0BoostThresholdValue_helper() const;
    double mBand1BoostThreshold;
    double defaultBand1BoostThresholdValue_helper() const;
    double mBand2BoostThreshold;
    double defaultBand2BoostThresholdValue_helper() const;
    double mBand3BoostThreshold;
    double defaultBand3BoostThresholdValue_helper() const;
    double mBand4BoostThreshold;
    double defaultBand4BoostThresholdValue_helper() const;
    double mBand5BoostThreshold;
    double defaultBand5BoostThresholdValue_helper() const;
    double mBand6BoostThreshold;
    double defaultBand6BoostThresholdValue_helper() const;
    double mBand7BoostThreshold;
    double defaultBand7BoostThresholdValue_helper() const;
    double mBand0BoostAmount;
    double defaultBand0BoostAmountValue_helper() const;
    double mBand1BoostAmount;
    double defaultBand1BoostAmountValue_helper() const;
    double mBand2BoostAmount;
    double defaultBand2BoostAmountValue_helper() const;
    double mBand3BoostAmount;
    double defaultBand3BoostAmountValue_helper() const;
    double mBand4BoostAmount;
    double defaultBand4BoostAmountValue_helper() const;
    double mBand5BoostAmount;
    double defaultBand5BoostAmountValue_helper() const;
    double mBand6BoostAmount;
    double defaultBand6BoostAmountValue_helper() const;
    double mBand7BoostAmount;
    double defaultBand7BoostAmountValue_helper() const;
    double mBand0Makeup;
    double defaultBand0MakeupValue_helper() const;
    double mBand1Makeup;
    double defaultBand1MakeupValue_helper() const;
    double mBand2Makeup;
    double defaultBand2MakeupValue_helper() const;
    double mBand3Makeup;
    double defaultBand3MakeupValue_helper() const;
    double mBand4Makeup;
    double defaultBand4MakeupValue_helper() const;
    double mBand5Makeup;
    double defaultBand5MakeupValue_helper() const;
    double mBand6Makeup;
    double defaultBand6MakeupValue_helper() const;
    double mBand7Makeup;
    double defaultBand7MakeupValue_helper() const;
};

#endif

