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

#include "kconfig_base_ee.hpp"

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

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

    DbCrystalizer( const QString & masterGroup, const QString & instanceIndex );
    ~DbCrystalizer() 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 adaptiveIntensity
    */
    void setAdaptiveIntensity( bool v )
    {
      if (v != mAdaptiveIntensity && !isAdaptiveIntensityImmutable()) {
        mAdaptiveIntensity = v;
        Q_EMIT adaptiveIntensityChanged();
      }
    }

    Q_PROPERTY(bool adaptiveIntensity READ adaptiveIntensity WRITE setAdaptiveIntensity NOTIFY adaptiveIntensityChanged)
    Q_PROPERTY(bool isAdaptiveIntensityImmutable READ isAdaptiveIntensityImmutable CONSTANT)
    Q_PROPERTY(bool defaultAdaptiveIntensityValue READ defaultAdaptiveIntensityValue CONSTANT)
    /**
      Get adaptiveIntensity
    */
    bool adaptiveIntensity() const
    {
      return mAdaptiveIntensity;
    }

    /**
      Is adaptiveIntensity Immutable
    */
    bool isAdaptiveIntensityImmutable() const
    {
      return isImmutable( QStringLiteral( "adaptiveIntensity" ) );
    }

    /**
      Get adaptiveIntensity default value
    */
    bool defaultAdaptiveIntensityValue() const
    {
        return defaultAdaptiveIntensityValue_helper();
    }

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

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

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

    /**
      Get oversampling default value
    */
    bool defaultOversamplingValue() const
    {
        return defaultOversamplingValue_helper();
    }

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

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

      if (v != mOversamplingQuality && !isOversamplingQualityImmutable()) {
        mOversamplingQuality = v;
        Q_EMIT oversamplingQualityChanged();
      }
    }

    Q_PROPERTY(double oversamplingQuality READ oversamplingQuality WRITE setOversamplingQuality NOTIFY oversamplingQualityChanged)
    Q_PROPERTY(bool isOversamplingQualityImmutable READ isOversamplingQualityImmutable CONSTANT)
    Q_PROPERTY(double defaultOversamplingQualityValue READ defaultOversamplingQualityValue CONSTANT)
    /**
      Get oversamplingQuality
    */
    double oversamplingQuality() const
    {
      return mOversamplingQuality;
    }

    /**
      Is oversamplingQuality Immutable
    */
    bool isOversamplingQualityImmutable() const
    {
      return isImmutable( QStringLiteral( "oversamplingQuality" ) );
    }

    /**
      Get oversamplingQuality default value
    */
    double defaultOversamplingQualityValue() const
    {
        return defaultOversamplingQualityValue_helper();
    }

    /**
      Set useFixedQuantum
    */
    void setUseFixedQuantum( bool v )
    {
      if (v != mUseFixedQuantum && !isUseFixedQuantumImmutable()) {
        mUseFixedQuantum = v;
        Q_EMIT useFixedQuantumChanged();
      }
    }

    Q_PROPERTY(bool useFixedQuantum READ useFixedQuantum WRITE setUseFixedQuantum NOTIFY useFixedQuantumChanged)
    Q_PROPERTY(bool isUseFixedQuantumImmutable READ isUseFixedQuantumImmutable CONSTANT)
    Q_PROPERTY(bool defaultUseFixedQuantumValue READ defaultUseFixedQuantumValue CONSTANT)
    /**
      Get useFixedQuantum
    */
    bool useFixedQuantum() const
    {
      return mUseFixedQuantum;
    }

    /**
      Is useFixedQuantum Immutable
    */
    bool isUseFixedQuantumImmutable() const
    {
      return isImmutable( QStringLiteral( "useFixedQuantum" ) );
    }

    /**
      Get useFixedQuantum default value
    */
    bool defaultUseFixedQuantumValue() const
    {
        return defaultUseFixedQuantumValue_helper();
    }

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

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

      if (v != mTransitionBand && !isTransitionBandImmutable()) {
        mTransitionBand = v;
        Q_EMIT transitionBandChanged();
      }
    }

    Q_PROPERTY(double transitionBand READ transitionBand WRITE setTransitionBand NOTIFY transitionBandChanged)
    Q_PROPERTY(bool isTransitionBandImmutable READ isTransitionBandImmutable CONSTANT)
    Q_PROPERTY(double defaultTransitionBandValue READ defaultTransitionBandValue CONSTANT)
    /**
      Get transitionBand
    */
    double transitionBand() const
    {
      return mTransitionBand;
    }

    /**
      Is transitionBand Immutable
    */
    bool isTransitionBandImmutable() const
    {
      return isImmutable( QStringLiteral( "transitionBand" ) );
    }

    /**
      Get transitionBand default value
    */
    double defaultTransitionBandValue() const
    {
        return defaultTransitionBandValue_helper();
    }

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

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

      if (v != mIntensityBand0 && !isIntensityBand0Immutable()) {
        mIntensityBand0 = v;
        Q_EMIT intensityBand0Changed();
      }
    }

    Q_PROPERTY(double intensityBand0 READ intensityBand0 WRITE setIntensityBand0 NOTIFY intensityBand0Changed)
    Q_PROPERTY(bool isIntensityBand0Immutable READ isIntensityBand0Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand0Value READ defaultIntensityBand0Value CONSTANT)
    /**
      Get intensityBand0
    */
    double intensityBand0() const
    {
      return mIntensityBand0;
    }

    /**
      Is intensityBand0 Immutable
    */
    bool isIntensityBand0Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand0" ) );
    }

    /**
      Get intensityBand0 default value
    */
    double defaultIntensityBand0Value() const
    {
        return defaultIntensityBand0Value_helper();
    }

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

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

      if (v != mIntensityBand1 && !isIntensityBand1Immutable()) {
        mIntensityBand1 = v;
        Q_EMIT intensityBand1Changed();
      }
    }

    Q_PROPERTY(double intensityBand1 READ intensityBand1 WRITE setIntensityBand1 NOTIFY intensityBand1Changed)
    Q_PROPERTY(bool isIntensityBand1Immutable READ isIntensityBand1Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand1Value READ defaultIntensityBand1Value CONSTANT)
    /**
      Get intensityBand1
    */
    double intensityBand1() const
    {
      return mIntensityBand1;
    }

    /**
      Is intensityBand1 Immutable
    */
    bool isIntensityBand1Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand1" ) );
    }

    /**
      Get intensityBand1 default value
    */
    double defaultIntensityBand1Value() const
    {
        return defaultIntensityBand1Value_helper();
    }

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

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

      if (v != mIntensityBand2 && !isIntensityBand2Immutable()) {
        mIntensityBand2 = v;
        Q_EMIT intensityBand2Changed();
      }
    }

    Q_PROPERTY(double intensityBand2 READ intensityBand2 WRITE setIntensityBand2 NOTIFY intensityBand2Changed)
    Q_PROPERTY(bool isIntensityBand2Immutable READ isIntensityBand2Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand2Value READ defaultIntensityBand2Value CONSTANT)
    /**
      Get intensityBand2
    */
    double intensityBand2() const
    {
      return mIntensityBand2;
    }

    /**
      Is intensityBand2 Immutable
    */
    bool isIntensityBand2Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand2" ) );
    }

    /**
      Get intensityBand2 default value
    */
    double defaultIntensityBand2Value() const
    {
        return defaultIntensityBand2Value_helper();
    }

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

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

      if (v != mIntensityBand3 && !isIntensityBand3Immutable()) {
        mIntensityBand3 = v;
        Q_EMIT intensityBand3Changed();
      }
    }

    Q_PROPERTY(double intensityBand3 READ intensityBand3 WRITE setIntensityBand3 NOTIFY intensityBand3Changed)
    Q_PROPERTY(bool isIntensityBand3Immutable READ isIntensityBand3Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand3Value READ defaultIntensityBand3Value CONSTANT)
    /**
      Get intensityBand3
    */
    double intensityBand3() const
    {
      return mIntensityBand3;
    }

    /**
      Is intensityBand3 Immutable
    */
    bool isIntensityBand3Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand3" ) );
    }

    /**
      Get intensityBand3 default value
    */
    double defaultIntensityBand3Value() const
    {
        return defaultIntensityBand3Value_helper();
    }

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

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

      if (v != mIntensityBand4 && !isIntensityBand4Immutable()) {
        mIntensityBand4 = v;
        Q_EMIT intensityBand4Changed();
      }
    }

    Q_PROPERTY(double intensityBand4 READ intensityBand4 WRITE setIntensityBand4 NOTIFY intensityBand4Changed)
    Q_PROPERTY(bool isIntensityBand4Immutable READ isIntensityBand4Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand4Value READ defaultIntensityBand4Value CONSTANT)
    /**
      Get intensityBand4
    */
    double intensityBand4() const
    {
      return mIntensityBand4;
    }

    /**
      Is intensityBand4 Immutable
    */
    bool isIntensityBand4Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand4" ) );
    }

    /**
      Get intensityBand4 default value
    */
    double defaultIntensityBand4Value() const
    {
        return defaultIntensityBand4Value_helper();
    }

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

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

      if (v != mIntensityBand5 && !isIntensityBand5Immutable()) {
        mIntensityBand5 = v;
        Q_EMIT intensityBand5Changed();
      }
    }

    Q_PROPERTY(double intensityBand5 READ intensityBand5 WRITE setIntensityBand5 NOTIFY intensityBand5Changed)
    Q_PROPERTY(bool isIntensityBand5Immutable READ isIntensityBand5Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand5Value READ defaultIntensityBand5Value CONSTANT)
    /**
      Get intensityBand5
    */
    double intensityBand5() const
    {
      return mIntensityBand5;
    }

    /**
      Is intensityBand5 Immutable
    */
    bool isIntensityBand5Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand5" ) );
    }

    /**
      Get intensityBand5 default value
    */
    double defaultIntensityBand5Value() const
    {
        return defaultIntensityBand5Value_helper();
    }

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

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

      if (v != mIntensityBand6 && !isIntensityBand6Immutable()) {
        mIntensityBand6 = v;
        Q_EMIT intensityBand6Changed();
      }
    }

    Q_PROPERTY(double intensityBand6 READ intensityBand6 WRITE setIntensityBand6 NOTIFY intensityBand6Changed)
    Q_PROPERTY(bool isIntensityBand6Immutable READ isIntensityBand6Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand6Value READ defaultIntensityBand6Value CONSTANT)
    /**
      Get intensityBand6
    */
    double intensityBand6() const
    {
      return mIntensityBand6;
    }

    /**
      Is intensityBand6 Immutable
    */
    bool isIntensityBand6Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand6" ) );
    }

    /**
      Get intensityBand6 default value
    */
    double defaultIntensityBand6Value() const
    {
        return defaultIntensityBand6Value_helper();
    }

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

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

      if (v != mIntensityBand7 && !isIntensityBand7Immutable()) {
        mIntensityBand7 = v;
        Q_EMIT intensityBand7Changed();
      }
    }

    Q_PROPERTY(double intensityBand7 READ intensityBand7 WRITE setIntensityBand7 NOTIFY intensityBand7Changed)
    Q_PROPERTY(bool isIntensityBand7Immutable READ isIntensityBand7Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand7Value READ defaultIntensityBand7Value CONSTANT)
    /**
      Get intensityBand7
    */
    double intensityBand7() const
    {
      return mIntensityBand7;
    }

    /**
      Is intensityBand7 Immutable
    */
    bool isIntensityBand7Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand7" ) );
    }

    /**
      Get intensityBand7 default value
    */
    double defaultIntensityBand7Value() const
    {
        return defaultIntensityBand7Value_helper();
    }

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

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

      if (v != mIntensityBand8 && !isIntensityBand8Immutable()) {
        mIntensityBand8 = v;
        Q_EMIT intensityBand8Changed();
      }
    }

    Q_PROPERTY(double intensityBand8 READ intensityBand8 WRITE setIntensityBand8 NOTIFY intensityBand8Changed)
    Q_PROPERTY(bool isIntensityBand8Immutable READ isIntensityBand8Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand8Value READ defaultIntensityBand8Value CONSTANT)
    /**
      Get intensityBand8
    */
    double intensityBand8() const
    {
      return mIntensityBand8;
    }

    /**
      Is intensityBand8 Immutable
    */
    bool isIntensityBand8Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand8" ) );
    }

    /**
      Get intensityBand8 default value
    */
    double defaultIntensityBand8Value() const
    {
        return defaultIntensityBand8Value_helper();
    }

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

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

      if (v != mIntensityBand9 && !isIntensityBand9Immutable()) {
        mIntensityBand9 = v;
        Q_EMIT intensityBand9Changed();
      }
    }

    Q_PROPERTY(double intensityBand9 READ intensityBand9 WRITE setIntensityBand9 NOTIFY intensityBand9Changed)
    Q_PROPERTY(bool isIntensityBand9Immutable READ isIntensityBand9Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand9Value READ defaultIntensityBand9Value CONSTANT)
    /**
      Get intensityBand9
    */
    double intensityBand9() const
    {
      return mIntensityBand9;
    }

    /**
      Is intensityBand9 Immutable
    */
    bool isIntensityBand9Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand9" ) );
    }

    /**
      Get intensityBand9 default value
    */
    double defaultIntensityBand9Value() const
    {
        return defaultIntensityBand9Value_helper();
    }

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

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

      if (v != mIntensityBand10 && !isIntensityBand10Immutable()) {
        mIntensityBand10 = v;
        Q_EMIT intensityBand10Changed();
      }
    }

    Q_PROPERTY(double intensityBand10 READ intensityBand10 WRITE setIntensityBand10 NOTIFY intensityBand10Changed)
    Q_PROPERTY(bool isIntensityBand10Immutable READ isIntensityBand10Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand10Value READ defaultIntensityBand10Value CONSTANT)
    /**
      Get intensityBand10
    */
    double intensityBand10() const
    {
      return mIntensityBand10;
    }

    /**
      Is intensityBand10 Immutable
    */
    bool isIntensityBand10Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand10" ) );
    }

    /**
      Get intensityBand10 default value
    */
    double defaultIntensityBand10Value() const
    {
        return defaultIntensityBand10Value_helper();
    }

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

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

      if (v != mIntensityBand11 && !isIntensityBand11Immutable()) {
        mIntensityBand11 = v;
        Q_EMIT intensityBand11Changed();
      }
    }

    Q_PROPERTY(double intensityBand11 READ intensityBand11 WRITE setIntensityBand11 NOTIFY intensityBand11Changed)
    Q_PROPERTY(bool isIntensityBand11Immutable READ isIntensityBand11Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand11Value READ defaultIntensityBand11Value CONSTANT)
    /**
      Get intensityBand11
    */
    double intensityBand11() const
    {
      return mIntensityBand11;
    }

    /**
      Is intensityBand11 Immutable
    */
    bool isIntensityBand11Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand11" ) );
    }

    /**
      Get intensityBand11 default value
    */
    double defaultIntensityBand11Value() const
    {
        return defaultIntensityBand11Value_helper();
    }

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

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

      if (v != mIntensityBand12 && !isIntensityBand12Immutable()) {
        mIntensityBand12 = v;
        Q_EMIT intensityBand12Changed();
      }
    }

    Q_PROPERTY(double intensityBand12 READ intensityBand12 WRITE setIntensityBand12 NOTIFY intensityBand12Changed)
    Q_PROPERTY(bool isIntensityBand12Immutable READ isIntensityBand12Immutable CONSTANT)
    Q_PROPERTY(double defaultIntensityBand12Value READ defaultIntensityBand12Value CONSTANT)
    /**
      Get intensityBand12
    */
    double intensityBand12() const
    {
      return mIntensityBand12;
    }

    /**
      Is intensityBand12 Immutable
    */
    bool isIntensityBand12Immutable() const
    {
      return isImmutable( QStringLiteral( "intensityBand12" ) );
    }

    /**
      Get intensityBand12 default value
    */
    double defaultIntensityBand12Value() const
    {
        return defaultIntensityBand12Value_helper();
    }

    /**
      Set muteBand0
    */
    void setMuteBand0( bool v )
    {
      if (v != mMuteBand0 && !isMuteBand0Immutable()) {
        mMuteBand0 = v;
        Q_EMIT muteBand0Changed();
      }
    }

    Q_PROPERTY(bool muteBand0 READ muteBand0 WRITE setMuteBand0 NOTIFY muteBand0Changed)
    Q_PROPERTY(bool isMuteBand0Immutable READ isMuteBand0Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand0Value READ defaultMuteBand0Value CONSTANT)
    /**
      Get muteBand0
    */
    bool muteBand0() const
    {
      return mMuteBand0;
    }

    /**
      Is muteBand0 Immutable
    */
    bool isMuteBand0Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand0" ) );
    }

    /**
      Get muteBand0 default value
    */
    bool defaultMuteBand0Value() const
    {
        return defaultMuteBand0Value_helper();
    }

    /**
      Set muteBand1
    */
    void setMuteBand1( bool v )
    {
      if (v != mMuteBand1 && !isMuteBand1Immutable()) {
        mMuteBand1 = v;
        Q_EMIT muteBand1Changed();
      }
    }

    Q_PROPERTY(bool muteBand1 READ muteBand1 WRITE setMuteBand1 NOTIFY muteBand1Changed)
    Q_PROPERTY(bool isMuteBand1Immutable READ isMuteBand1Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand1Value READ defaultMuteBand1Value CONSTANT)
    /**
      Get muteBand1
    */
    bool muteBand1() const
    {
      return mMuteBand1;
    }

    /**
      Is muteBand1 Immutable
    */
    bool isMuteBand1Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand1" ) );
    }

    /**
      Get muteBand1 default value
    */
    bool defaultMuteBand1Value() const
    {
        return defaultMuteBand1Value_helper();
    }

    /**
      Set muteBand2
    */
    void setMuteBand2( bool v )
    {
      if (v != mMuteBand2 && !isMuteBand2Immutable()) {
        mMuteBand2 = v;
        Q_EMIT muteBand2Changed();
      }
    }

    Q_PROPERTY(bool muteBand2 READ muteBand2 WRITE setMuteBand2 NOTIFY muteBand2Changed)
    Q_PROPERTY(bool isMuteBand2Immutable READ isMuteBand2Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand2Value READ defaultMuteBand2Value CONSTANT)
    /**
      Get muteBand2
    */
    bool muteBand2() const
    {
      return mMuteBand2;
    }

    /**
      Is muteBand2 Immutable
    */
    bool isMuteBand2Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand2" ) );
    }

    /**
      Get muteBand2 default value
    */
    bool defaultMuteBand2Value() const
    {
        return defaultMuteBand2Value_helper();
    }

    /**
      Set muteBand3
    */
    void setMuteBand3( bool v )
    {
      if (v != mMuteBand3 && !isMuteBand3Immutable()) {
        mMuteBand3 = v;
        Q_EMIT muteBand3Changed();
      }
    }

    Q_PROPERTY(bool muteBand3 READ muteBand3 WRITE setMuteBand3 NOTIFY muteBand3Changed)
    Q_PROPERTY(bool isMuteBand3Immutable READ isMuteBand3Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand3Value READ defaultMuteBand3Value CONSTANT)
    /**
      Get muteBand3
    */
    bool muteBand3() const
    {
      return mMuteBand3;
    }

    /**
      Is muteBand3 Immutable
    */
    bool isMuteBand3Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand3" ) );
    }

    /**
      Get muteBand3 default value
    */
    bool defaultMuteBand3Value() const
    {
        return defaultMuteBand3Value_helper();
    }

    /**
      Set muteBand4
    */
    void setMuteBand4( bool v )
    {
      if (v != mMuteBand4 && !isMuteBand4Immutable()) {
        mMuteBand4 = v;
        Q_EMIT muteBand4Changed();
      }
    }

    Q_PROPERTY(bool muteBand4 READ muteBand4 WRITE setMuteBand4 NOTIFY muteBand4Changed)
    Q_PROPERTY(bool isMuteBand4Immutable READ isMuteBand4Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand4Value READ defaultMuteBand4Value CONSTANT)
    /**
      Get muteBand4
    */
    bool muteBand4() const
    {
      return mMuteBand4;
    }

    /**
      Is muteBand4 Immutable
    */
    bool isMuteBand4Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand4" ) );
    }

    /**
      Get muteBand4 default value
    */
    bool defaultMuteBand4Value() const
    {
        return defaultMuteBand4Value_helper();
    }

    /**
      Set muteBand5
    */
    void setMuteBand5( bool v )
    {
      if (v != mMuteBand5 && !isMuteBand5Immutable()) {
        mMuteBand5 = v;
        Q_EMIT muteBand5Changed();
      }
    }

    Q_PROPERTY(bool muteBand5 READ muteBand5 WRITE setMuteBand5 NOTIFY muteBand5Changed)
    Q_PROPERTY(bool isMuteBand5Immutable READ isMuteBand5Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand5Value READ defaultMuteBand5Value CONSTANT)
    /**
      Get muteBand5
    */
    bool muteBand5() const
    {
      return mMuteBand5;
    }

    /**
      Is muteBand5 Immutable
    */
    bool isMuteBand5Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand5" ) );
    }

    /**
      Get muteBand5 default value
    */
    bool defaultMuteBand5Value() const
    {
        return defaultMuteBand5Value_helper();
    }

    /**
      Set muteBand6
    */
    void setMuteBand6( bool v )
    {
      if (v != mMuteBand6 && !isMuteBand6Immutable()) {
        mMuteBand6 = v;
        Q_EMIT muteBand6Changed();
      }
    }

    Q_PROPERTY(bool muteBand6 READ muteBand6 WRITE setMuteBand6 NOTIFY muteBand6Changed)
    Q_PROPERTY(bool isMuteBand6Immutable READ isMuteBand6Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand6Value READ defaultMuteBand6Value CONSTANT)
    /**
      Get muteBand6
    */
    bool muteBand6() const
    {
      return mMuteBand6;
    }

    /**
      Is muteBand6 Immutable
    */
    bool isMuteBand6Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand6" ) );
    }

    /**
      Get muteBand6 default value
    */
    bool defaultMuteBand6Value() const
    {
        return defaultMuteBand6Value_helper();
    }

    /**
      Set muteBand7
    */
    void setMuteBand7( bool v )
    {
      if (v != mMuteBand7 && !isMuteBand7Immutable()) {
        mMuteBand7 = v;
        Q_EMIT muteBand7Changed();
      }
    }

    Q_PROPERTY(bool muteBand7 READ muteBand7 WRITE setMuteBand7 NOTIFY muteBand7Changed)
    Q_PROPERTY(bool isMuteBand7Immutable READ isMuteBand7Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand7Value READ defaultMuteBand7Value CONSTANT)
    /**
      Get muteBand7
    */
    bool muteBand7() const
    {
      return mMuteBand7;
    }

    /**
      Is muteBand7 Immutable
    */
    bool isMuteBand7Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand7" ) );
    }

    /**
      Get muteBand7 default value
    */
    bool defaultMuteBand7Value() const
    {
        return defaultMuteBand7Value_helper();
    }

    /**
      Set muteBand8
    */
    void setMuteBand8( bool v )
    {
      if (v != mMuteBand8 && !isMuteBand8Immutable()) {
        mMuteBand8 = v;
        Q_EMIT muteBand8Changed();
      }
    }

    Q_PROPERTY(bool muteBand8 READ muteBand8 WRITE setMuteBand8 NOTIFY muteBand8Changed)
    Q_PROPERTY(bool isMuteBand8Immutable READ isMuteBand8Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand8Value READ defaultMuteBand8Value CONSTANT)
    /**
      Get muteBand8
    */
    bool muteBand8() const
    {
      return mMuteBand8;
    }

    /**
      Is muteBand8 Immutable
    */
    bool isMuteBand8Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand8" ) );
    }

    /**
      Get muteBand8 default value
    */
    bool defaultMuteBand8Value() const
    {
        return defaultMuteBand8Value_helper();
    }

    /**
      Set muteBand9
    */
    void setMuteBand9( bool v )
    {
      if (v != mMuteBand9 && !isMuteBand9Immutable()) {
        mMuteBand9 = v;
        Q_EMIT muteBand9Changed();
      }
    }

    Q_PROPERTY(bool muteBand9 READ muteBand9 WRITE setMuteBand9 NOTIFY muteBand9Changed)
    Q_PROPERTY(bool isMuteBand9Immutable READ isMuteBand9Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand9Value READ defaultMuteBand9Value CONSTANT)
    /**
      Get muteBand9
    */
    bool muteBand9() const
    {
      return mMuteBand9;
    }

    /**
      Is muteBand9 Immutable
    */
    bool isMuteBand9Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand9" ) );
    }

    /**
      Get muteBand9 default value
    */
    bool defaultMuteBand9Value() const
    {
        return defaultMuteBand9Value_helper();
    }

    /**
      Set muteBand10
    */
    void setMuteBand10( bool v )
    {
      if (v != mMuteBand10 && !isMuteBand10Immutable()) {
        mMuteBand10 = v;
        Q_EMIT muteBand10Changed();
      }
    }

    Q_PROPERTY(bool muteBand10 READ muteBand10 WRITE setMuteBand10 NOTIFY muteBand10Changed)
    Q_PROPERTY(bool isMuteBand10Immutable READ isMuteBand10Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand10Value READ defaultMuteBand10Value CONSTANT)
    /**
      Get muteBand10
    */
    bool muteBand10() const
    {
      return mMuteBand10;
    }

    /**
      Is muteBand10 Immutable
    */
    bool isMuteBand10Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand10" ) );
    }

    /**
      Get muteBand10 default value
    */
    bool defaultMuteBand10Value() const
    {
        return defaultMuteBand10Value_helper();
    }

    /**
      Set muteBand11
    */
    void setMuteBand11( bool v )
    {
      if (v != mMuteBand11 && !isMuteBand11Immutable()) {
        mMuteBand11 = v;
        Q_EMIT muteBand11Changed();
      }
    }

    Q_PROPERTY(bool muteBand11 READ muteBand11 WRITE setMuteBand11 NOTIFY muteBand11Changed)
    Q_PROPERTY(bool isMuteBand11Immutable READ isMuteBand11Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand11Value READ defaultMuteBand11Value CONSTANT)
    /**
      Get muteBand11
    */
    bool muteBand11() const
    {
      return mMuteBand11;
    }

    /**
      Is muteBand11 Immutable
    */
    bool isMuteBand11Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand11" ) );
    }

    /**
      Get muteBand11 default value
    */
    bool defaultMuteBand11Value() const
    {
        return defaultMuteBand11Value_helper();
    }

    /**
      Set muteBand12
    */
    void setMuteBand12( bool v )
    {
      if (v != mMuteBand12 && !isMuteBand12Immutable()) {
        mMuteBand12 = v;
        Q_EMIT muteBand12Changed();
      }
    }

    Q_PROPERTY(bool muteBand12 READ muteBand12 WRITE setMuteBand12 NOTIFY muteBand12Changed)
    Q_PROPERTY(bool isMuteBand12Immutable READ isMuteBand12Immutable CONSTANT)
    Q_PROPERTY(bool defaultMuteBand12Value READ defaultMuteBand12Value CONSTANT)
    /**
      Get muteBand12
    */
    bool muteBand12() const
    {
      return mMuteBand12;
    }

    /**
      Is muteBand12 Immutable
    */
    bool isMuteBand12Immutable() const
    {
      return isImmutable( QStringLiteral( "muteBand12" ) );
    }

    /**
      Get muteBand12 default value
    */
    bool defaultMuteBand12Value() const
    {
        return defaultMuteBand12Value_helper();
    }

    /**
      Set bypassBand0
    */
    void setBypassBand0( bool v )
    {
      if (v != mBypassBand0 && !isBypassBand0Immutable()) {
        mBypassBand0 = v;
        Q_EMIT bypassBand0Changed();
      }
    }

    Q_PROPERTY(bool bypassBand0 READ bypassBand0 WRITE setBypassBand0 NOTIFY bypassBand0Changed)
    Q_PROPERTY(bool isBypassBand0Immutable READ isBypassBand0Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand0Value READ defaultBypassBand0Value CONSTANT)
    /**
      Get bypassBand0
    */
    bool bypassBand0() const
    {
      return mBypassBand0;
    }

    /**
      Is bypassBand0 Immutable
    */
    bool isBypassBand0Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand0" ) );
    }

    /**
      Get bypassBand0 default value
    */
    bool defaultBypassBand0Value() const
    {
        return defaultBypassBand0Value_helper();
    }

    /**
      Set bypassBand1
    */
    void setBypassBand1( bool v )
    {
      if (v != mBypassBand1 && !isBypassBand1Immutable()) {
        mBypassBand1 = v;
        Q_EMIT bypassBand1Changed();
      }
    }

    Q_PROPERTY(bool bypassBand1 READ bypassBand1 WRITE setBypassBand1 NOTIFY bypassBand1Changed)
    Q_PROPERTY(bool isBypassBand1Immutable READ isBypassBand1Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand1Value READ defaultBypassBand1Value CONSTANT)
    /**
      Get bypassBand1
    */
    bool bypassBand1() const
    {
      return mBypassBand1;
    }

    /**
      Is bypassBand1 Immutable
    */
    bool isBypassBand1Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand1" ) );
    }

    /**
      Get bypassBand1 default value
    */
    bool defaultBypassBand1Value() const
    {
        return defaultBypassBand1Value_helper();
    }

    /**
      Set bypassBand2
    */
    void setBypassBand2( bool v )
    {
      if (v != mBypassBand2 && !isBypassBand2Immutable()) {
        mBypassBand2 = v;
        Q_EMIT bypassBand2Changed();
      }
    }

    Q_PROPERTY(bool bypassBand2 READ bypassBand2 WRITE setBypassBand2 NOTIFY bypassBand2Changed)
    Q_PROPERTY(bool isBypassBand2Immutable READ isBypassBand2Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand2Value READ defaultBypassBand2Value CONSTANT)
    /**
      Get bypassBand2
    */
    bool bypassBand2() const
    {
      return mBypassBand2;
    }

    /**
      Is bypassBand2 Immutable
    */
    bool isBypassBand2Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand2" ) );
    }

    /**
      Get bypassBand2 default value
    */
    bool defaultBypassBand2Value() const
    {
        return defaultBypassBand2Value_helper();
    }

    /**
      Set bypassBand3
    */
    void setBypassBand3( bool v )
    {
      if (v != mBypassBand3 && !isBypassBand3Immutable()) {
        mBypassBand3 = v;
        Q_EMIT bypassBand3Changed();
      }
    }

    Q_PROPERTY(bool bypassBand3 READ bypassBand3 WRITE setBypassBand3 NOTIFY bypassBand3Changed)
    Q_PROPERTY(bool isBypassBand3Immutable READ isBypassBand3Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand3Value READ defaultBypassBand3Value CONSTANT)
    /**
      Get bypassBand3
    */
    bool bypassBand3() const
    {
      return mBypassBand3;
    }

    /**
      Is bypassBand3 Immutable
    */
    bool isBypassBand3Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand3" ) );
    }

    /**
      Get bypassBand3 default value
    */
    bool defaultBypassBand3Value() const
    {
        return defaultBypassBand3Value_helper();
    }

    /**
      Set bypassBand4
    */
    void setBypassBand4( bool v )
    {
      if (v != mBypassBand4 && !isBypassBand4Immutable()) {
        mBypassBand4 = v;
        Q_EMIT bypassBand4Changed();
      }
    }

    Q_PROPERTY(bool bypassBand4 READ bypassBand4 WRITE setBypassBand4 NOTIFY bypassBand4Changed)
    Q_PROPERTY(bool isBypassBand4Immutable READ isBypassBand4Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand4Value READ defaultBypassBand4Value CONSTANT)
    /**
      Get bypassBand4
    */
    bool bypassBand4() const
    {
      return mBypassBand4;
    }

    /**
      Is bypassBand4 Immutable
    */
    bool isBypassBand4Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand4" ) );
    }

    /**
      Get bypassBand4 default value
    */
    bool defaultBypassBand4Value() const
    {
        return defaultBypassBand4Value_helper();
    }

    /**
      Set bypassBand5
    */
    void setBypassBand5( bool v )
    {
      if (v != mBypassBand5 && !isBypassBand5Immutable()) {
        mBypassBand5 = v;
        Q_EMIT bypassBand5Changed();
      }
    }

    Q_PROPERTY(bool bypassBand5 READ bypassBand5 WRITE setBypassBand5 NOTIFY bypassBand5Changed)
    Q_PROPERTY(bool isBypassBand5Immutable READ isBypassBand5Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand5Value READ defaultBypassBand5Value CONSTANT)
    /**
      Get bypassBand5
    */
    bool bypassBand5() const
    {
      return mBypassBand5;
    }

    /**
      Is bypassBand5 Immutable
    */
    bool isBypassBand5Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand5" ) );
    }

    /**
      Get bypassBand5 default value
    */
    bool defaultBypassBand5Value() const
    {
        return defaultBypassBand5Value_helper();
    }

    /**
      Set bypassBand6
    */
    void setBypassBand6( bool v )
    {
      if (v != mBypassBand6 && !isBypassBand6Immutable()) {
        mBypassBand6 = v;
        Q_EMIT bypassBand6Changed();
      }
    }

    Q_PROPERTY(bool bypassBand6 READ bypassBand6 WRITE setBypassBand6 NOTIFY bypassBand6Changed)
    Q_PROPERTY(bool isBypassBand6Immutable READ isBypassBand6Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand6Value READ defaultBypassBand6Value CONSTANT)
    /**
      Get bypassBand6
    */
    bool bypassBand6() const
    {
      return mBypassBand6;
    }

    /**
      Is bypassBand6 Immutable
    */
    bool isBypassBand6Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand6" ) );
    }

    /**
      Get bypassBand6 default value
    */
    bool defaultBypassBand6Value() const
    {
        return defaultBypassBand6Value_helper();
    }

    /**
      Set bypassBand7
    */
    void setBypassBand7( bool v )
    {
      if (v != mBypassBand7 && !isBypassBand7Immutable()) {
        mBypassBand7 = v;
        Q_EMIT bypassBand7Changed();
      }
    }

    Q_PROPERTY(bool bypassBand7 READ bypassBand7 WRITE setBypassBand7 NOTIFY bypassBand7Changed)
    Q_PROPERTY(bool isBypassBand7Immutable READ isBypassBand7Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand7Value READ defaultBypassBand7Value CONSTANT)
    /**
      Get bypassBand7
    */
    bool bypassBand7() const
    {
      return mBypassBand7;
    }

    /**
      Is bypassBand7 Immutable
    */
    bool isBypassBand7Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand7" ) );
    }

    /**
      Get bypassBand7 default value
    */
    bool defaultBypassBand7Value() const
    {
        return defaultBypassBand7Value_helper();
    }

    /**
      Set bypassBand8
    */
    void setBypassBand8( bool v )
    {
      if (v != mBypassBand8 && !isBypassBand8Immutable()) {
        mBypassBand8 = v;
        Q_EMIT bypassBand8Changed();
      }
    }

    Q_PROPERTY(bool bypassBand8 READ bypassBand8 WRITE setBypassBand8 NOTIFY bypassBand8Changed)
    Q_PROPERTY(bool isBypassBand8Immutable READ isBypassBand8Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand8Value READ defaultBypassBand8Value CONSTANT)
    /**
      Get bypassBand8
    */
    bool bypassBand8() const
    {
      return mBypassBand8;
    }

    /**
      Is bypassBand8 Immutable
    */
    bool isBypassBand8Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand8" ) );
    }

    /**
      Get bypassBand8 default value
    */
    bool defaultBypassBand8Value() const
    {
        return defaultBypassBand8Value_helper();
    }

    /**
      Set bypassBand9
    */
    void setBypassBand9( bool v )
    {
      if (v != mBypassBand9 && !isBypassBand9Immutable()) {
        mBypassBand9 = v;
        Q_EMIT bypassBand9Changed();
      }
    }

    Q_PROPERTY(bool bypassBand9 READ bypassBand9 WRITE setBypassBand9 NOTIFY bypassBand9Changed)
    Q_PROPERTY(bool isBypassBand9Immutable READ isBypassBand9Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand9Value READ defaultBypassBand9Value CONSTANT)
    /**
      Get bypassBand9
    */
    bool bypassBand9() const
    {
      return mBypassBand9;
    }

    /**
      Is bypassBand9 Immutable
    */
    bool isBypassBand9Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand9" ) );
    }

    /**
      Get bypassBand9 default value
    */
    bool defaultBypassBand9Value() const
    {
        return defaultBypassBand9Value_helper();
    }

    /**
      Set bypassBand10
    */
    void setBypassBand10( bool v )
    {
      if (v != mBypassBand10 && !isBypassBand10Immutable()) {
        mBypassBand10 = v;
        Q_EMIT bypassBand10Changed();
      }
    }

    Q_PROPERTY(bool bypassBand10 READ bypassBand10 WRITE setBypassBand10 NOTIFY bypassBand10Changed)
    Q_PROPERTY(bool isBypassBand10Immutable READ isBypassBand10Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand10Value READ defaultBypassBand10Value CONSTANT)
    /**
      Get bypassBand10
    */
    bool bypassBand10() const
    {
      return mBypassBand10;
    }

    /**
      Is bypassBand10 Immutable
    */
    bool isBypassBand10Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand10" ) );
    }

    /**
      Get bypassBand10 default value
    */
    bool defaultBypassBand10Value() const
    {
        return defaultBypassBand10Value_helper();
    }

    /**
      Set bypassBand11
    */
    void setBypassBand11( bool v )
    {
      if (v != mBypassBand11 && !isBypassBand11Immutable()) {
        mBypassBand11 = v;
        Q_EMIT bypassBand11Changed();
      }
    }

    Q_PROPERTY(bool bypassBand11 READ bypassBand11 WRITE setBypassBand11 NOTIFY bypassBand11Changed)
    Q_PROPERTY(bool isBypassBand11Immutable READ isBypassBand11Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand11Value READ defaultBypassBand11Value CONSTANT)
    /**
      Get bypassBand11
    */
    bool bypassBand11() const
    {
      return mBypassBand11;
    }

    /**
      Is bypassBand11 Immutable
    */
    bool isBypassBand11Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand11" ) );
    }

    /**
      Get bypassBand11 default value
    */
    bool defaultBypassBand11Value() const
    {
        return defaultBypassBand11Value_helper();
    }

    /**
      Set bypassBand12
    */
    void setBypassBand12( bool v )
    {
      if (v != mBypassBand12 && !isBypassBand12Immutable()) {
        mBypassBand12 = v;
        Q_EMIT bypassBand12Changed();
      }
    }

    Q_PROPERTY(bool bypassBand12 READ bypassBand12 WRITE setBypassBand12 NOTIFY bypassBand12Changed)
    Q_PROPERTY(bool isBypassBand12Immutable READ isBypassBand12Immutable CONSTANT)
    Q_PROPERTY(bool defaultBypassBand12Value READ defaultBypassBand12Value CONSTANT)
    /**
      Get bypassBand12
    */
    bool bypassBand12() const
    {
      return mBypassBand12;
    }

    /**
      Is bypassBand12 Immutable
    */
    bool isBypassBand12Immutable() const
    {
      return isImmutable( QStringLiteral( "bypassBand12" ) );
    }

    /**
      Get bypassBand12 default value
    */
    bool defaultBypassBand12Value() const
    {
        return defaultBypassBand12Value_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalAdaptiveIntensityChanged = 4,
      signalOversamplingChanged = 5,
      signalOversamplingQualityChanged = 6,
      signalUseFixedQuantumChanged = 7,
      signalTransitionBandChanged = 8,
      signalIntensityBand0Changed = 9,
      signalIntensityBand1Changed = 10,
      signalIntensityBand2Changed = 11,
      signalIntensityBand3Changed = 12,
      signalIntensityBand4Changed = 13,
      signalIntensityBand5Changed = 14,
      signalIntensityBand6Changed = 15,
      signalIntensityBand7Changed = 16,
      signalIntensityBand8Changed = 17,
      signalIntensityBand9Changed = 18,
      signalIntensityBand10Changed = 19,
      signalIntensityBand11Changed = 20,
      signalIntensityBand12Changed = 21,
      signalMuteBand0Changed = 22,
      signalMuteBand1Changed = 23,
      signalMuteBand2Changed = 24,
      signalMuteBand3Changed = 25,
      signalMuteBand4Changed = 26,
      signalMuteBand5Changed = 27,
      signalMuteBand6Changed = 28,
      signalMuteBand7Changed = 29,
      signalMuteBand8Changed = 30,
      signalMuteBand9Changed = 31,
      signalMuteBand10Changed = 32,
      signalMuteBand11Changed = 33,
      signalMuteBand12Changed = 34,
      signalBypassBand0Changed = 35,
      signalBypassBand1Changed = 36,
      signalBypassBand2Changed = 37,
      signalBypassBand3Changed = 38,
      signalBypassBand4Changed = 39,
      signalBypassBand5Changed = 40,
      signalBypassBand6Changed = 41,
      signalBypassBand7Changed = 42,
      signalBypassBand8Changed = 43,
      signalBypassBand9Changed = 44,
      signalBypassBand10Changed = 45,
      signalBypassBand11Changed = 46,
      signalBypassBand12Changed = 47
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void adaptiveIntensityChanged();

    void oversamplingChanged();

    void oversamplingQualityChanged();

    void useFixedQuantumChanged();

    void transitionBandChanged();

    void intensityBand0Changed();

    void intensityBand1Changed();

    void intensityBand2Changed();

    void intensityBand3Changed();

    void intensityBand4Changed();

    void intensityBand5Changed();

    void intensityBand6Changed();

    void intensityBand7Changed();

    void intensityBand8Changed();

    void intensityBand9Changed();

    void intensityBand10Changed();

    void intensityBand11Changed();

    void intensityBand12Changed();

    void muteBand0Changed();

    void muteBand1Changed();

    void muteBand2Changed();

    void muteBand3Changed();

    void muteBand4Changed();

    void muteBand5Changed();

    void muteBand6Changed();

    void muteBand7Changed();

    void muteBand8Changed();

    void muteBand9Changed();

    void muteBand10Changed();

    void muteBand11Changed();

    void muteBand12Changed();

    void bypassBand0Changed();

    void bypassBand1Changed();

    void bypassBand2Changed();

    void bypassBand3Changed();

    void bypassBand4Changed();

    void bypassBand5Changed();

    void bypassBand6Changed();

    void bypassBand7Changed();

    void bypassBand8Changed();

    void bypassBand9Changed();

    void bypassBand10Changed();

    void bypassBand11Changed();

    void bypassBand12Changed();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // Crystalizer#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    bool mAdaptiveIntensity;
    bool defaultAdaptiveIntensityValue_helper() const;
    bool mOversampling;
    bool defaultOversamplingValue_helper() const;
    double mOversamplingQuality;
    double defaultOversamplingQualityValue_helper() const;
    bool mUseFixedQuantum;
    bool defaultUseFixedQuantumValue_helper() const;
    double mTransitionBand;
    double defaultTransitionBandValue_helper() const;
    double mIntensityBand0;
    double defaultIntensityBand0Value_helper() const;
    double mIntensityBand1;
    double defaultIntensityBand1Value_helper() const;
    double mIntensityBand2;
    double defaultIntensityBand2Value_helper() const;
    double mIntensityBand3;
    double defaultIntensityBand3Value_helper() const;
    double mIntensityBand4;
    double defaultIntensityBand4Value_helper() const;
    double mIntensityBand5;
    double defaultIntensityBand5Value_helper() const;
    double mIntensityBand6;
    double defaultIntensityBand6Value_helper() const;
    double mIntensityBand7;
    double defaultIntensityBand7Value_helper() const;
    double mIntensityBand8;
    double defaultIntensityBand8Value_helper() const;
    double mIntensityBand9;
    double defaultIntensityBand9Value_helper() const;
    double mIntensityBand10;
    double defaultIntensityBand10Value_helper() const;
    double mIntensityBand11;
    double defaultIntensityBand11Value_helper() const;
    double mIntensityBand12;
    double defaultIntensityBand12Value_helper() const;
    bool mMuteBand0;
    bool defaultMuteBand0Value_helper() const;
    bool mMuteBand1;
    bool defaultMuteBand1Value_helper() const;
    bool mMuteBand2;
    bool defaultMuteBand2Value_helper() const;
    bool mMuteBand3;
    bool defaultMuteBand3Value_helper() const;
    bool mMuteBand4;
    bool defaultMuteBand4Value_helper() const;
    bool mMuteBand5;
    bool defaultMuteBand5Value_helper() const;
    bool mMuteBand6;
    bool defaultMuteBand6Value_helper() const;
    bool mMuteBand7;
    bool defaultMuteBand7Value_helper() const;
    bool mMuteBand8;
    bool defaultMuteBand8Value_helper() const;
    bool mMuteBand9;
    bool defaultMuteBand9Value_helper() const;
    bool mMuteBand10;
    bool defaultMuteBand10Value_helper() const;
    bool mMuteBand11;
    bool defaultMuteBand11Value_helper() const;
    bool mMuteBand12;
    bool defaultMuteBand12Value_helper() const;
    bool mBypassBand0;
    bool defaultBypassBand0Value_helper() const;
    bool mBypassBand1;
    bool defaultBypassBand1Value_helper() const;
    bool mBypassBand2;
    bool defaultBypassBand2Value_helper() const;
    bool mBypassBand3;
    bool defaultBypassBand3Value_helper() const;
    bool mBypassBand4;
    bool defaultBypassBand4Value_helper() const;
    bool mBypassBand5;
    bool defaultBypassBand5Value_helper() const;
    bool mBypassBand6;
    bool defaultBypassBand6Value_helper() const;
    bool mBypassBand7;
    bool defaultBypassBand7Value_helper() const;
    bool mBypassBand8;
    bool defaultBypassBand8Value_helper() const;
    bool mBypassBand9;
    bool defaultBypassBand9Value_helper() const;
    bool mBypassBand10;
    bool defaultBypassBand10Value_helper() const;
    bool mBypassBand11;
    bool defaultBypassBand11Value_helper() const;
    bool mBypassBand12;
    bool defaultBypassBand12Value_helper() const;
};

#endif

